artindnr/khayyam-challenge

Khayyam Challenge

Khayyam Challenge is a benchmark for evaluating whether AI models can move between classical Persian poetry and natural-language Persian prose without losing meaning, imagery, and literary structure. It supports two directions:

• Poem → Prose: given a classical Persian poem, produce a faithful prose description.
• Prose → Poem: given a prose description (with the original poem hidden), reconstruct a new poem that preserves the source poem's meaning, imagery, and — ideally — its poetic structure.

The dataset pairs 20 classical Persian poems (Hafez, Ferdowsi, and others) with two independently AI-generated prose "descriptions" of each poem, produced by two different LLMs (internally referred to as Luna and Terra). The prose versions strip away verse form and direct wording while preserving core meaning, so a model attempting the Prose → Poem direction cannot simply copy the original.

This dataset accompanies the Persian Poetry Challenge framework, which also provides an automated pipeline for running generation + AI-judge scoring against this data.

Dataset structure

The dataset has three configs, each split into low / medium / long by poem length:

Config	Description	Rows per split
poems	The 20 source poems with metadata	low: 10, medium: 7, long: 3
prose_luna	Poems + prose description generated by the "Luna" model	low: 10, medium: 7, long: 3
prose_terra	Poems + prose description generated by the "Terra" model	low: 10, medium: 7, long: 3

from datasets import load_dataset

poems = load_dataset("artindnr/khayyam-challenge", "poems")
prose_luna = load_dataset("artindnr/khayyam-challenge", "prose_luna")
prose_terra = load_dataset("artindnr/khayyam-challenge", "prose_terra")

poem = poems["low"][0]
prose = prose_luna["low"][0]
assert poem["id"] == prose["id"]  # same poem, join key
print(prose["conversion"]["prose"])

Records in poems, prose_luna, and prose_terra are joined on id within each split. id is only unique within a split (low/medium/long), not across splits — always join within the same split.

Length categories

Split	# poems	Verses per poem	Notes
low	10	1–7 beyts	Short ghazals/quatrains; good for quick iteration
medium	7	7–20 beyts	Longer ghazals; more complex imagery and structure
long	3	20–50 beyts	Excerpts from epic mathnavi (e.g. Ferdowsi's Shahnameh); narrative + philosophical depth

Schema

Every split shares the same columns (required so datasets/the Hub viewer can build each config), but not every field is meaningful in every split — this reflects the source material, not a data error:

• All splits: id, poet, title, form, verse_count, theme, text (list of verses, hemistichs joined with /).
• meter, notes: populated only for low; "" (empty string) elsewhere.
• verified: populated only for low (whether the transcription was manually checked against a reference edition); false elsewhere — this is a "not applicable" default, not a claim that medium/long poems are unverified.
• selected_section: populated only for long (which excerpt of a longer narrative poem this record covers, since full epics run to thousands of beyts); "" elsewhere.

If you're filtering or displaying these fields, treat "" / false in the non-native split as "not applicable" rather than as real values.

prose_luna and prose_terra records contain everything in poems plus a conversion object:

"conversion": {
  "model": "gpt-5.6-luna",   // or gpt-5.6-terra
  "version": "1",
  "prose": "..."             // the generated Persian prose description
}

Intended use: the two benchmark tasks

1. Poem → Prose. Give a model poems[split][i]["text"] and ask it to produce a fluent Persian prose description that preserves meaning, imagery, emotional register, and narrative/philosophical content without directly quoting the verse. Score the output against prose_luna/prose_terra as references, or with a judge model using a rubric (see below).

2. Prose → Poem. Give a model a prose description from prose_luna or prose_terra (with the source poem withheld) and ask it to generate a new Persian poem conveying the same meaning. Score the generated poem against the original in poems using a judge model.

Suggested scoring rubric

The reference implementation (evaluate_poetry.py) scores Prose → Poem generations on a 0–10 scale across five weighted criteria:

Criterion	Weight	What it measures
Semantic similarity	30%	Meaning preservation vs. the source prose/poem
Rhyme quality	20%	Correct rhyme patterns, sound harmony, consistency
Meter accuracy	20%	Persian prosody, rhythm, correct poetic meter
Literary devices	15%	Use of metaphor, simile, symbolism, imagery
Semantic depth	15%	Philosophical/emotional depth, originality

final_score = 0.30·semantic + 0.20·rhyme + 0.20·meter + 0.15·literary + 0.15·depth

This dataset does not ship pre-computed judge scores — scoring is meant to run against whatever generation model and judge model you're evaluating. See the companion repo for a runnable harness (config.json + evaluate_poetry.py) that takes any OpenAI-compatible generation/judge endpoint.

Data collection

• Poems: classical Persian poems (public domain), manually curated and, for the low split, cross-checked against reference editions (see verified/notes).
• Prose: generated by prompting two different LLMs (internally labeled Luna and Terra) to render each poem as Persian prose, preserving meaning while removing verse form. Each poem has one prose version per model.

Known limitations

• Small dataset (20 poems total) — intended as a focused diagnostic benchmark, not a large-scale training corpus.
• Prose descriptions are themselves AI-generated and not independently human-verified; they may carry over interpretive choices or errors from the generating model.
• verified/notes in the low split describe verification of the poem transcription, not the prose description.
• Meter/rhyme scoring in the suggested rubric depends on the judge model's own competence at Persian prosody, which varies significantly across models — treat absolute scores cautiously and prefer relative comparisons between systems evaluated with the same judge.

Licensing

• The source poems are classical Persian works in the public domain.
• The compilation, curation, metadata, and AI-generated prose in this dataset are released under CC BY 4.0. Attribution: cite this dataset (see below) when using it.

Citation

If you use this dataset, please cite:

@misc{khayyam-challenge,
  title  = {Khayyam Challenge: A Persian Poem-Prose Benchmark},
  author = {Artin},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/datasets/artindnr/khayyam-challenge}},
  note   = {Companion framework: \url{https://github.com/Artin200912/Persian-Poetry-Challenge}}
}

Links

• Evaluation framework / harness: https://github.com/Artin200912/Persian-Poetry-Challenge