README.md

---
language:
- en
task_categories:
- text-retrieval
size_categories:
- 1K<n<10K
dataset_info:
- config_name: documents
  features:
  - name: chunk_id
    dtype: string
  - name: chunk
    dtype: string
  - name: source_url
    dtype: string
  - name: title
    dtype: string
  - name: chunk_idx
    dtype: int64
  - name: chunk_start_char
    dtype: int64
  - name: chunk_end_char
    dtype: int64
  splits:
  - name: test
    num_bytes: 1761506
    num_examples: 4936
  download_size: 600220
  dataset_size: 1761506
- config_name: queries
  features:
  - name: original_query
    dtype: string
  - name: query
    dtype: string
  - name: answer
    list: string
  - name: score
    list: int64
  - name: source_url
    list: string
  - name: frag_start_char
    list: int64
  - name: frag_end_char
    list: int64
  - name: n_gold
    dtype: int64
  - name: roles
    list: string
  - name: fact
    dtype: string
  splits:
  - name: test
    num_bytes: 26959
    num_examples: 38
  download_size: 14279
  dataset_size: 26959
configs:
- config_name: documents
  data_files:
  - split: test
    path: documents/test-*
- config_name: queries
  data_files:
  - split: test
    path: queries/test-*
---

# EDGAR 8-K — Context Chunk Retrieval (coreference + near-duplicate)

A contextualized sentence-level (query2chunk) retrieval eval built from **SEC 8-K
restructuring filings** (EDGAR), for the
[Chunk-level Retrieval Eval](https://huggingface.co/collections/bowang0911/chunk-level-retrieval-eval)
collection.

**Why this benchmark exists.** Standard passage benchmarks (e.g. DAPR) don't discriminate
contextual embedding models, because their answer passages already contain the
distinguishing entity and have no near-duplicate distractors. This dataset is built to
stress **document-context disambiguation**:

- **Sentence chunks are coreference-dependent** — the answer sentence says *"the Company"*,
  never the company name, so resolving it requires the surrounding document.
- **Near-identical distractors across companies** — 8-Ks are templated, so the corpus holds
  dozens of near-identical sentences like *"the Company estimates that it will incur charges
  of approximately $X million"* differing only by amount/company. In isolation these are
  indistinguishable; only the document context resolves which "Company" is meant.

Example — query *"What restructuring charges does Elastic expect to incur?"* → answer
*"The Company expects to incur total non-recurring cash charges of approximately $22 million
to $25 million…"* competes against 58 near-identical charge sentences from other filings.

## Stats

| | count |
| --- | --- |
| documents (filings) | 246 |
| corpus (sentence chunks) | 4,936 |
| queries | 38 (28 with a supporting-evidence fragment) |
| near-duplicate charge sentences | 58 |
| near-duplicate workforce sentences | 53 |

## Graded gold: answer vs supporting evidence

Gold is **graded** via the standard `score` field (no schema change vs the rest of the
collection):

| `score` | role | meaning |
| --- | --- | --- |
| **2** | `answer` | the sentence that directly answers the query (uses coreference) |
| **1** | `evidence` | a supporting fact that disambiguates the answer (e.g. the sentence binding the company name to *"the Company"*) |

Derive the two metrics from one qrels:
```python
standard_recall@k = |topk ∩ {score >= 2}| / |{score >= 2}|   # answer only
evidence_recall@k = |topk ∩ {score >= 1}| / |{score >= 1}|   # answer + supporting evidence
```
`nDCG@k` can consume the graded scores directly. A human-readable `roles` field
(`answer` / `evidence`) mirrors the score. Backward compatible: datasets that use
`score = 1` uniformly are answer-only (no evidence tier).

## Configs

### `documents`
`chunk_id`, `chunk` (one sentence), `source_url` (filing accession — **group chunks by this
to give a contextual model its document view**), `title` (company + 8-K date),
`chunk_idx` (sentence position in the filing), `chunk_start_char` / `chunk_end_char`.

### `queries`
`original_query` / `query`, `answer[]` (gold sentence texts), `score[]` (2=answer, 1=evidence),
`source_url[]` (filing per gold), `frag_start_char[]` / `frag_end_char[]`, `n_gold`,
`roles[]` (`answer`/`evidence`), `fact` (`workforce` / `charges`).

Gold matching: a chunk is gold for a query if it shares `source_url` and its
`[chunk_start_char, chunk_end_char)` overlaps a gold fragment's span (each gold maps to
exactly one sentence chunk).

## Construction & limitations

Built from EDGAR full-text search for restructuring 8-Ks (2022–2026), one primary filing per
company. HTML cleaned (inline-XBRL/hidden/exhibit boilerplate stripped, sliced to the Item
narrative), sentence-split with **NLTK Punkt**, junk/heading/fragment chunks removed.

- **Prototype scale** — 38 queries; the query set skews toward `charges` (workforce answers
  more often repeat the company name and are filtered out to preserve the coreference axis).
- **Templated queries** — 2 regex-generated templates (`workforce`, `charges`); phrasing
  overlaps the gold, so the difficulty is the coreference/near-duplicate disambiguation, not
  the wording. A natural/LLM-generated query pass is future work.
- **Evidence coverage** — 28/38 queries have a supporting-evidence fragment; the rest are
  answer-only.

Source: public SEC EDGAR filings (U.S. government works / public domain).