data/README.md

---
language: en
lic-ense: cc-by-4.0
tags: [linear-algebra, llm-evaluation, error-analysis, mathematical-reasoning, benchmark]
size_categories: [1K<n<10K]
configs:
  features:
    - name: Problem_ID
      dtype: string
    - name: Model
      dtype: string
    - name: Subcat
      dtype: string
    - name: problem_latex
      dtype: string
    - name: answer_latex
      dtype: string
    - name: Model_Response
      dtype: string
    - name: Correct
      dtype: string
    - name: Error_Tag
      dtype: string
    - name: validated
      dtype: bool
  splits:
    - name: benchmark
      num_examples: 660
    - name: model_outputs
      num_examples: 6600
    - name: error_annotations
      num_examples: 2549
    - name: results
  config_name: "default"
---

# LinAlg-Bench: A Forensic Benchmark Revealing Structural Failure Modes in LLM Mathematical Reasoning

A diagnostic benchmark evaluating 10 frontier LLMs on linear algebra computation across a strict dimensional gradient (3×3, 4×4, 5×5 matrices), with automated three-stage forensic error classification revealing that LLM mathematical failure is structurally constrained by algorithm family and matrix dimension rather than random.

## Overview

LinAlg-Bench is a diagnostic dataset of LLM responses and forensic error annotations on linear algebra computation tasks. It covers 660 problems across three matrix sizes (3×3, 4×4, 5×5) and nine operation types (determinant, eigenvalues, rank, nullity, trace, multiplication, matrix power, matrix-vector product, transpose), evaluated on 10 frontier models. Each failure is annotated with a fine-grained error tag and subtype via a three-stage automated forensic pipeline (Gemini-3.1-Pro judge + meta-auditor).

## Data Structure

```
data/
├── benchmark/                      # Problem definitions (SymPy-certified ground truth)
│   ├── train-00000.parquet        # 3×3: 220 unique problems
│   ├── train-00001.parquet        # 4×4: 220 unique problems
│   └── train-00002.parquet        # 5×5: 220 unique problems
├── model_outputs/                  # Stage 1: Raw model responses and correct status
│   ├── train-00000.parquet        # 3×3: model inference on 220 Problem_IDs for 10 models
│   ├── train-00001.parquet        # 4×4: model inference on 220 Problem_IDs for 10 models
│   └── train-00002.parquet        # 5×5: model inference on 220 Problem_IDs for 10 models
├── error_annotations/              # Stage 3: Forensic error labels (validated)
│   ├── train-00000.parquet        # 3×3: 335 failures classified
│   ├── train-00001.parquet        # 4×4: 879 failures classified
│   └── train-00002.parquet        # 5×5: 1,335 failures classified
└── results/                        # Aggregated summaries per size
    ├── accuracy/                   # Model accuracy by task/size
    ├── error_tags/                 # Error tag distribution per subcategory (10–14 tags by size)
    ├── sign_subtypes/              # Sign error breakdown (8–9 subtypes by size)
    └── hallucination_subtypes/     # Hallucination breakdown (4–6 subtypes by size)
```

## Data Notes


**Model naming convention :** Model names are inconsistent across splits. `model_outputs` and `results/accuracy` use long-form provider slugs (e.g. `google/gemma-3-12B-it`, `qwen/qwen-2.5-14b-instruct`), while `error_annotations` uses short-form names (e.g. `Gemma-3-12B`, `Qwen2.5-14B`). A direct join between the two on `(Problem_ID, Model)` will not match any model. Normalize names before joining. The mapping is:

| `model_outputs` / `results` | `error_annotations` |
|---|---|
| `google/gemma-3-4b-it` | `Gemma-3-4B` |
| `google/gemma-3-12B-it` | `Gemma-3-12B` |
| `google/gemma-3-27b-it` | `Gemma-3-27B` |
| `meta-llama/llama-3.1-8b-instruct` | `Llama-3.1-8B` |
| `mistralai/ministral-8b-2512` | `Mistral-8B` |
| `mistralai/ministral-14b-2512` | `Mistral-14B` |
| `mistralai/mistral-small-24b-instruct-2501` | `Mistral-24B` |
| `qwen/qwen-2.5-7b-instruct` | `Qwen2.5-7B` |
| `qwen/qwen-2.5-14b-instruct` | `Qwen2.5-14B` |
| `qwen/qwen-2.5-32b-instruct` | `Qwen2.5-32B` |

## Usage Examples

### Load with Hugging Face Datasets

```python
from datasets import load_dataset

# Load full dataset
ds = load_dataset("05deepak/demo")

# Load specific splits
benchmark = ds['benchmark']           # Problem definitions
model_outputs = ds['model_outputs']   # Stage 1 responses
errors = ds['error_annotations']      # Forensic labels
results = ds['results']               # Aggregated summaries

# Access a records
record = model_outputs[0]
print(f"Problem: {record['Problem_ID']}")
print(f"Model: {record['Model']}")
print(f"Task: {record['Subcat']}")
print(f"Correct: {record['Correct']}")

# Access an error annotation
error = errors[0]
print(f"Error tag: {error['Final_tags']}")
print(f"Validated: {error['validated']}")
```

## Limitations

1. **Domain-specific**: Linear algebra only. Generalization to other mathematical domains is out of scope for the present research.

2. **Snapshot in time**: All inferences performed May 2026. Model updates or API changes after this date are not reflected.

3. **Scale limit**: Maximum 5×5 matrices. Behaviour at larger scales is out of scope for the present research.


## Ethical Considerations & Responsible Use

### Recommended Use Cases
✅ Research on symbolic reasoning in LLMs  
✅ Analyzing systematic error patterns and failure modes  
✅ Identifying mechanistic bottlenecks (working memory, strategy rigidity)  
✅ Developing better post-training curricula for mathematical reasoning  

### Caution / Not Recommended For
❌ Definitive model ranking — single benchmark is insufficient for production decisions  
❌ Knowledge claims — this measures execution under specific conditions (T=0, no tools)  
❌ General reasoning ability assessment — linear algebra is narrow domain  
❌ Marketing claims — benchmark results are domain-specific diagnostics, not overall capability metrics  

### Known Biases
- **Synthetic problems**: Small integer entries [-10, 10] may not reflect real-world distribution
- **Format bias**: LaTeX consistently helps at recursive levels (model-specific)
- **Training data**: Newer models (those with larger training corpora) may have seen more matrix problems

## File Manifest

| File | Rows | Columns | Purpose |
|------|------|---------|---------|
| benchmark/train-000{00,01,02}.parquet | 220 each | 5 | Unique problems per size (LaTeX) |
| model_outputs/train-000{00,01,02}.parquet | 2,200 each | 20 | All model responses + metadata |
| error_annotations/train-000{00,01,02}.parquet | 335/879/1,335 | 23 | Failures with forensic labels |
| results/accuracy/train-000{00,01,02}.parquet | 10 rows each | 5 | Model accuracy per task |
| results/error_tags/train-000{00,01,02}.parquet | 8/9/9 rows | 15/16/12 | Error tag distribution per subcategory |
| results/sign_subtypes/train-000{00,01,02}.parquet | 5/7/6 rows | 10/10/11 | Sign error breakdown per subcategory |
| results/hallucination_subtypes/train-000{00,01,02}.parquet | 3/8/7 rows | 6/8/8 | Hallucination breakdown per subcategory |

## Citation

```bibtex
@inproceedings{linalgbench2026,
  title={LinAlg-Bench: A Forensic Benchmark Revealing Structural Failure Modes in LLM Mathematical Reasoning},
  author={Anonymous},
  booktitle={Advances in Neural Information Processing Systems (NeurIPS) - Datasets and Benchmarks Track},
  year={2026}
}
```

## License

CC BY 4.0 — freely available for research and commercial use with attribution.

## Acknowledgments

- **Model API Access**: OpenAI, Google DeepMind, Mistral, Qwen, Meta
- **SymPy Verification**: Symbolic mathematics backend for ground truth
- **Annotation**: Three-stage automated pipeline (Gemini-3.1-Pro judge + meta-auditor)

## Contact & Support

**Issues/Questions**: Open issue on GitHub or discussion on HF Hub  
**Dataset Updates**: Check release notes for new versions, bug fixes, model additions  
**Cite This Work**: See citation section above

---

**Dataset Hub**: [05deepak/demo](https://huggingface.co/datasets/05deepak/demo)  
**Paper**: [NeurIPS 2026 Datasets & Benchmarks Track](https://neurips.cc)  
**Code & Reproduction**: [GitHub Repository](https://github.com/05deepak/LinAlg-Bench)