Correct the Yousefmd finding: only shaping ran, not bidi

Re-measured on 1,000 labels across the whole 20,000-row split: 3 to 50 forms per label, 0 of 5,423 multi-form words begin with a FINAL form, and reshape(NFKC(stored)) reproduces the stored string for 1,000 of 1,000. Ships verify_yousefmd.py so every figure is re-derivable from one sample.

FINDINGS.md

@@ -38,21 +38,28 @@ scanned with the detector from `arabic-lint` 0.5.0. 100 rows per dataset, first
 ### One dataset carries presentation forms in every sampled label, and it is an OCR ground-truth set
 
 **`Yousefmd/arabic_ocr_dataset`** — every text field stores presentation forms:
-4 to 54 per label (median 24), INITIAL, MEDIAL, FINAL and ISOLATED forms together.
-Verified across four sample windows: **400 of 400 fields, 100%**, 444 of 457 findings being
-runs of five or more forms.
+3 to 50 per label (median 24), INITIAL, MEDIAL, FINAL and ISOLATED forms together.
+Verified on **1,000 of 1,000 labels, 100%**, sampled through ten windows spanning the whole
+20,000-row split; in the audit's own 100-row scan, 444 of 457 findings are runs of five or
+more forms. Every figure here is re-derivable with `python3 verify_yousefmd.py`.
 
 **Only the shaping half of the recipe ran.** The words are in logical order, so
 `unicodedata.normalize("NFKC", stored)` alone recovers the text and no reversal is wanted.
 Two independent checks against the live rows:
 
-- of **2,130** sampled words carrying more than one presentation form, **0** begin with a
-  FINAL form and **0** meaningfully end with an INITIAL form (one does, `الـ`, and that is a
-  correctly shaped lam before a tatweel, not visual order). A word written in visual order
+- of **5,423** sampled words carrying more than one presentation form, **0** begin with a
+  FINAL form and **0** meaningfully end with an INITIAL form (one does, `الـ20`, and that is
+  a correctly shaped lam before a tatweel, not visual order). A word written in visual order
   reads FINAL-first from memory, so zero is decisive.
-- `arabic_reshaper.reshape(NFKC(stored)) == stored` for **400 of 400** fields. The stored
+- `arabic_reshaper.reshape(NFKC(stored)) == stored` for **1,000 of 1,000** labels. The stored
   string is exactly `reshape()` output with `get_display()` never applied.
 
+⚠️ The counts above are the corrected ones. A first pass classified a presentation form by
+testing the Unicode name for `ARABIC LETTER ... FORM`, which **silently drops every lam-alef
+ligature** (U+FEF5-FEFC are named `ARABIC LIGATURE ...`) — an undercount sitting exactly on
+the character the visual-order test is most sensitive to. The check now asks arabic-lint's own
+`is_presentation_form()`, so these numbers cannot drift from what the tool reports.
+
 This matters more than its size because the corrupted field is the **label**. A model
 trained on it learns to emit presentation forms instead of plain letters, so its output will
 not compare equal to ordinary Arabic even when the recognition is correct. That is the
@@ -137,9 +144,9 @@ signature". Only the first ran.
 
 Measured against the live rows on 13 September: plain `unicodedata.normalize("NFKC", stored)`
 returns `بدأت قراءة الصفحات الأولى على نغمات`, correct readable Arabic in logical order, with
-no reversal of any kind. Structurally, 0 of 2,130 multi-form words begin with a FINAL form.
+no reversal of any kind. Structurally, 0 of 5,423 multi-form words begin with a FINAL form.
 And `arabic_reshaper.reshape(NFKC(stored))` reproduces the stored string byte for byte in
-400 of 400 fields, which pins down exactly which half ran.
+1,000 of 1,000 labels, which pins down exactly which half ran.
 
 **The part that mattered was the advice, not the wording.** The discussion warned that
 recovery "is not simply NFKC plus reverse" because a lam-alef ligature would come back
@@ -147,8 +154,8 @@ swapped. That hazard exists only when the surrounding text is in visual order. H
 not: `ﻻﺑﻌﺪ` becomes `لابعد` and `ﻭﻻﻧﻲ` becomes `ولاني`, both correct. We told a maintainer
 his problem was harder than it is, in public, on his own repository.
 
-Also corrected in the same pass: "23 to 29 presentation forms per label" (real range 4 to
-54, median 24), and "fully corrupted" where "carries stored presentation forms in every
+Also corrected in the same pass: "23 to 29 presentation forms per label" (real range 3 to
+50, median 24), and "fully corrupted" where "carries stored presentation forms in every
 sampled field" is what was measured.
 
 **Cause.** The detector reports stored glyph forms. Word order is a separate property, was

README.md

@@ -95,18 +95,21 @@ spans are in a single dataset.**
 
 **276 datasets readable · 26,318 rows · 119,517 text fields · 21 with any finding · 1 with a presentation form in every sampled field.**
 
-**`Yousefmd/arabic_ocr_dataset` stores presentation forms in every sampled label** — 400 of
-400 fields across four sample windows, 4 to 54 presentation forms per label (median 24),
-INITIAL/MEDIAL/FINAL/ISOLATED forms together.
+**`Yousefmd/arabic_ocr_dataset` stores presentation forms in every sampled label** — 1,000 of
+1,000 labels, sampled through ten windows spanning the whole 20,000-row split, 3 to 50
+presentation forms per label (median 24), INITIAL/MEDIAL/FINAL/ISOLATED forms together.
 
 **Only the shaping half of the recipe ran there.** The words are in normal **logical**
 order, not visual order, so `unicodedata.normalize("NFKC", text)` alone recovers the
-text correctly and no reversal is needed. Measured two ways: on 2,130 sampled words
+text correctly and no reversal is needed. Measured two ways: on 5,423 sampled words
 carrying more than one presentation form, **0 begin with a FINAL form**, which is what
 visual order looks like in memory; and `arabic_reshaper.reshape(NFKC(stored)) == stored`
-for **400 of 400** fields, so the stored string is exactly `reshape()` output with
+for **1,000 of 1,000** labels, so the stored string is exactly `reshape()` output with
 `get_display()` never applied. An earlier version of this card claimed visual order. That
-was wrong. See *Corrections*.
+was wrong. See *Corrections*. Both figures are re-derivable with the shipped
+`verify_yousefmd.py`, which asks arabic-lint's own `is_presentation_form()` rather than
+matching Unicode names — a name test for `ARABIC LETTER ... FORM` drops every lam-alef
+ligature, which is the one character this measurement is most sensitive to.
 
 It matters because the corrupted field is the **label** of an OCR set: a model trained on
 it learns to emit presentation forms rather than plain letters, so its output will not
@@ -175,12 +178,12 @@ findings write-up and a discussion opened on that repository all stated that the
 been through `arabic_reshaper.reshape()` **and** `bidi.algorithm.get_display()`, and called
 that "the recipe's complete signature". Only the shaping step ran. Verified two ways against
 the live rows: plain `unicodedata.normalize("NFKC", stored)` returns correct readable Arabic
-in logical order with no reversal, and of 2,130 multi-form words **0** begin with a FINAL
+in logical order with no reversal, and of 5,423 multi-form words **0** begin with a FINAL
 form. The practical consequence is that the repair advice given was wrong in the worse
 direction: it warned that recovery needed more than NFKC because of the lam-alef ligature,
 when for this data **NFKC alone is a complete and safe repair**. The counts were sound; the
 mechanism inferred from them was not. Also corrected in the same pass: "23 to 29 presentation
-forms per label" (real range 4 to 54, median 24) and the headline word "corrupted" where
+forms per label" (real range 3 to 50, median 24) and the headline word "corrupted" where
 "carries stored presentation forms" is what was actually measured.
 
 **Cause, stated plainly.** The detector reports stored glyph forms. Visual order is a

verify_yousefmd.py

@@ -0,0 +1,102 @@
+"""
+Re-derive every published number about `Yousefmd/arabic_ocr_dataset` from one defined sample.
+
+One sample, one set of figures, so nothing quoted anywhere can disagree with anything else.
+Reads rows through the datasets-server (no download). `arabic_reshaper` is optional: without
+it the round-trip line is skipped rather than guessed.
+
+    python3 verify_yousefmd.py
+"""
+from __future__ import annotations
+
+import json
+import statistics
+import sys
+import unicodedata
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "arabic_lint" / "src"))
+from arabic_lint.detect import is_presentation_form  # noqa: E402
+
+DATASET = "Yousefmd/arabic_ocr_dataset"
+WINDOWS = 10          # evenly spaced across the split
+PER_WINDOW = 100      # rows per window (the API maximum)
+
+
+def fetch(offset: int, length: int) -> dict:
+    query = urllib.parse.urlencode(
+        {"dataset": DATASET, "config": "default", "split": "train",
+         "offset": offset, "length": length}
+    )
+    url = f"https://datasets-server.huggingface.co/rows?{query}"
+    with urllib.request.urlopen(url, timeout=90) as response:
+        return json.load(response)
+
+
+def presentation_form(char: str) -> str | None:
+    """Return ISOLATED/INITIAL/MEDIAL/FINAL for a presentation form, else None.
+
+    Whether a codepoint counts as a presentation form is decided by arabic-lint itself,
+    so these figures cannot drift from what the tool reports. The positional class is then
+    read off the Unicode NAME, which covers the lam-alef *ligature* forms (U+FEF5-FEFC)
+    as well as the plain letter forms - their names are `ARABIC LIGATURE ...`, so a check
+    that only accepts `ARABIC LETTER ...` silently undercounts every lam-alef.
+    """
+    if not is_presentation_form(char):
+        return None
+    tail = unicodedata.name(char).split()[-2:]
+    return tail[0] if tail[1] == "FORM" and tail[0] in {
+        "ISOLATED", "INITIAL", "MEDIAL", "FINAL"} else None
+
+
+def main() -> None:
+    total = fetch(0, 1)["num_rows_total"]
+    offsets = [min(total * i // WINDOWS, max(total - PER_WINDOW, 0)) for i in range(WINDOWS)]
+
+    labels: list[str] = []
+    for offset in offsets:
+        for row in fetch(offset, PER_WINDOW)["rows"]:
+            value = row["row"].get("text")
+            if isinstance(value, str) and value.strip():
+                labels.append(value)
+
+    counts = [sum(1 for char in label if presentation_form(char)) for label in labels]
+    with_forms = [count for count in counts if count]
+
+    multi_form_words = 0
+    starting_final = 0
+    ending_initial: list[str] = []
+    for label in labels:
+        for word in label.split():
+            forms = [f for f in (presentation_form(c) for c in word) if f]
+            if len(forms) > 1:
+                multi_form_words += 1
+                starting_final += forms[0] == "FINAL"
+                if forms[-1] == "INITIAL":
+                    ending_initial.append(word)
+
+    print(f"dataset            {DATASET}")
+    print(f"rows in split      {total}")
+    print(f"sample             {len(labels)} labels, {WINDOWS} windows at offsets {offsets}")
+    print(f"carry forms        {len(with_forms)} of {len(labels)}")
+    print(f"forms per label    min {min(with_forms)}  max {max(with_forms)}  "
+          f"median {statistics.median(with_forms):.0f}")
+    print(f"multi-form words   {multi_form_words}, starting with a FINAL form: {starting_final}")
+    print(f"ending INITIAL     {len(ending_initial)} distinct: {sorted(set(ending_initial))[:5]}")
+
+    try:
+        import arabic_reshaper
+    except ImportError:
+        print("round trip        skipped (arabic_reshaper not installed)")
+        return
+    matches = sum(
+        arabic_reshaper.reshape(unicodedata.normalize("NFKC", label)) == label
+        for label in labels
+    )
+    print(f"round trip         reshape(NFKC(stored)) == stored for {matches} of {len(labels)}")
+
+
+if __name__ == "__main__":
+    main()