Update cognate pair scripts + borrowing/similarity data (P0-P2 fixes)

data/training/cognate_pairs/cognate_pairs_borrowing.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9f47de196443c307429b5e50fff4fb1888779bed16f7ba8999f8973dd607921b
-size 1888180
+oid sha256:7d7716625f51aded69e1b8d0552d2db0d1e23a9c9baec4ca0a94f6b5dfd02fd2
+size 1902720

data/training/cognate_pairs/cognate_pairs_similarity.tsv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7e7e7d4afb94c19667282056348d1a16c68ccb3294eab41029a48c5e064beefb
-size 25518124
+oid sha256:c9c8b9317d4395721cd9c8a89761fe2aa6ca7dacf16d64a7b3aac9955f863b44
+size 49930045

docs/DATABASE_REFERENCE.md

@@ -1,6 +1,6 @@
 # Ancient Scripts Datasets — Master Database Reference
 
-> **Last updated:** 2026-03-13 | **Commit:** `3e3fdf1` | **Total entries:** 3,466,000+ across 1,178 languages
+> **Last updated:** 2026-03-14 | **Commit:** `bfb61c2` | **Total entries:** 3,466,000+ across 1,178 languages
 
 This document is the single source of truth for understanding, modifying, and extending this database. It is designed for both human researchers and AI agents.
 
@@ -137,18 +137,20 @@ Lang_A  Word_A  IPA_A  Lang_B  Word_B  IPA_B  Concept_ID  Relationship  Score  S
 
 | File | Rows | Description |
 |------|------|-------------|
-| `cognate_pairs_inherited.tsv` | 21,298,208 | Expert-classified cognates + concept-aligned pairs (score ≥ 0.5) |
-| `cognate_pairs_borrowing.tsv` | 17,924 | Verified donor→recipient borrowings from WOLD BorrowingTable |
-| `cognate_pairs_similarity.tsv` | 231,784 | Phonetically similar pairs (0.3 ≤ score < 0.5), no overlap with inherited |
-
-**Sources:**
-- ABVD CognateTable (21.6M expert cognate pairs, 1,682 Austronesian languages)
-- IE-CoR CognateTable (412K Indo-European cognate pairs)
-- Sino-Tibetan CognateTable (4.2K pairs, borrowings filtered)
-- WOLD BorrowingTable (17.9K verified donor-recipient pairs)
-- Internal concept-aligned pairs (233K) + similarity pairs (254K)
-
-**Deduplication:** Priority ordering expert_cognate > borrowing > concept_aligned > similarity_only. Cross-file dedup ensures no language-concept combo appears in both inherited and similarity files. See `docs/prd/PRD_COGNATE_PAIRS_V2.md` for full specification.
+| `cognate_pairs_inherited.tsv` | 21,067,818 | Expert-classified cognates ONLY (ABVD + IE-CoR + Sino-Tibetan) |
+| `cognate_pairs_borrowing.tsv` | 17,147 | Verified donor→recipient borrowings from WOLD BorrowingTable |
+| `cognate_pairs_similarity.tsv` | 465,233 | Algorithmic phonetic similarity: concept_aligned (219,519, score ≥ 0.5) + similarity_only (245,714, 0.3 ≤ score < 0.5) |
+
+**Sources & provenance:**
+- **ABVD** CognateTable (20,697,739 pairs, 1,682 Austronesian languages) — Expert-classified by Greenhill, Blust & Gray (2008). Sister-sister relationships within cognate sets. `loan_flagged` for 160,768 pairs where ABVD Loan column non-empty.
+- **IE-CoR** CognateTable (365,913 pairs, 159 Indo-European languages) — Expert-classified by Heggarty et al. (2023, Science). Mixed PIE-level (32%) and branch-level (55%) cognacy. `loan_involved` for 3,598 pairs where cognateset appears in loans.csv.
+- **Sino-Tibetan** CognateTable (4,166 pairs) — Expert-classified from STEDT-derived data (Jacques & List). Borrowings (146 entries) pre-filtered at extraction.
+- **WOLD** BorrowingTable (17,147 pairs) — Expert borrowing judgments from Haspelmath & Tadmor (2009). `borrowed_immediate` (13,967) vs `borrowed_earlier` (3,180). Score = -1 sentinel for pseudo-IPA entries. Entries with "no evidence for borrowing" (802) filtered out.
+- **Concept-aligned** (219,519 pairs) + **Similarity-only** (245,714 pairs) — Algorithmically generated via SCA phonetic comparison within same language family. NOT expert cognates. Isolate and constructed languages excluded.
+
+**Deduplication:** Priority ordering expert_cognate > borrowing > concept_aligned > similarity_only. Pass 1.5 pre-populates expert language-concept keys across ALL files before writing, ensuring no concept_aligned/similarity pair duplicates an expert pair. See `docs/prd/PRD_COGNATE_PAIRS_V2.md` for full specification.
+
+**Adversarial audit status (2026-03-14):** All 3 output files PASS final audit. Zero cross-file contamination, zero self-pairs, zero isolate/constructed language leakage, all Source_Record_IDs traceable to source databases.
 
 ---
 

scripts/extract_abvd_cognates_v2.py

@@ -89,7 +89,7 @@ def main():
                 lang_iso[lid] = iso
     print(f"  Languages with ISO codes: {len(lang_iso)}")
 
-    # Step 2: Read forms.csv → Form_ID → {language, word, ipa, concept}
+    # Step 2: Read forms.csv → Form_ID → {language, word, ipa, concept, loan}
     forms_path = SOURCES_DIR / "forms.csv"
     forms = {}
     with open(forms_path, "r", encoding="utf-8") as f:
@@ -107,11 +107,13 @@ def main():
             # Extract concept from Parameter_ID (e.g., "1_hand" → "hand")
             concept = param_id.split("_", 1)[1] if "_" in param_id else param_id
             ipa = form_to_pseudo_ipa(form)
+            loan = row.get("Loan", "").strip()
             forms[fid] = {
                 "iso": iso,
                 "word": form,
                 "ipa": ipa,
                 "concept": concept,
+                "loan": loan,
             }
     print(f"  Forms loaded: {len(forms)}")
 
@@ -145,6 +147,7 @@ def main():
     # Step 4: Generate cross-language pairs within each cognate set
     output_path = STAGING_DIR / "abvd_cognate_pairs.tsv"
     pair_count = 0
+    loan_flagged_count = 0
     with open(output_path, "w", encoding="utf-8") as out:
         out.write(HEADER)
         for cogset_id, members in cogsets.items():
@@ -164,17 +167,26 @@ def main():
                     continue
                 score = sca_similarity(a["ipa"], b["ipa"])
                 confidence = "doubtful" if (a["doubt"] or b["doubt"]) else "certain"
+                # Check if either form is flagged as a loan
+                a_loan = a.get("loan", "")
+                b_loan = b.get("loan", "")
+                if (a_loan and a_loan.lower() != "false") or (b_loan and b_loan.lower() != "false"):
+                    relation_detail = "loan_flagged"
+                    loan_flagged_count += 1
+                else:
+                    relation_detail = "inherited"
                 out.write(
                     f"{a['iso']}\t{a['word']}\t{a['ipa']}\t"
                     f"{b['iso']}\t{b['word']}\t{b['ipa']}\t"
                     f"{a['concept']}\texpert_cognate\t{score}\tabvd\t"
-                    f"inherited\t-\t{confidence}\t{cogset_id}\n"
+                    f"{relation_detail}\t-\t{confidence}\t{cogset_id}\n"
                 )
                 pair_count += 1
                 if pair_count % 500000 == 0:
                     print(f"    ... {pair_count:,} pairs written")
 
     print(f"\n  Total pairs: {pair_count:,}")
+    print(f"  Loan-flagged pairs: {loan_flagged_count:,}")
     print(f"  Output: {output_path}")
     print("=" * 60)
 

scripts/extract_iecor_cognates.py

@@ -122,7 +122,19 @@ def main():
             }
     print(f"  Forms loaded: {len(forms)}")
 
-    # Step 4: Read cognates.csv → group by Cognateset_ID
+    # Step 4a: Read loans.csv → collect Cognateset_IDs involved in loans
+    loans_path = SOURCES_DIR / "loans.csv"
+    loan_cogset_ids: set[str] = set()
+    if loans_path.exists():
+        with open(loans_path, "r", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            for row in reader:
+                cid = row.get("Cognateset_ID", "").strip()
+                if cid:
+                    loan_cogset_ids.add(cid)
+    print(f"  Loan-involved cognate sets: {len(loan_cogset_ids)}")
+
+    # Step 4b: Read cognates.csv → group by Cognateset_ID
     cognates_path = SOURCES_DIR / "cognates.csv"
     cogsets: dict[str, list[dict]] = defaultdict(list)
     doubt_count = 0
@@ -151,9 +163,13 @@ def main():
     # Step 5: Generate cross-language pairs
     output_path = STAGING_DIR / "iecor_cognate_pairs.tsv"
     pair_count = 0
+    loan_pair_count = 0
+    inherited_pair_count = 0
     with open(output_path, "w", encoding="utf-8") as out:
         out.write(HEADER)
         for cogset_id, members in cogsets.items():
+            is_loan = cogset_id in loan_cogset_ids
+            relation_detail = "loan_involved" if is_loan else "inherited"
             for a, b in combinations(members, 2):
                 if a["iso"] == b["iso"]:
                     continue
@@ -163,13 +179,19 @@ def main():
                     f"{a['iso']}\t{a['word']}\t{a['ipa']}\t"
                     f"{b['iso']}\t{b['word']}\t{b['ipa']}\t"
                     f"{a['concept']}\texpert_cognate\t{score}\tiecor\t"
-                    f"inherited\t-\t{confidence}\t{cogset_id}\n"
+                    f"{relation_detail}\t-\t{confidence}\t{cogset_id}\n"
                 )
                 pair_count += 1
+                if is_loan:
+                    loan_pair_count += 1
+                else:
+                    inherited_pair_count += 1
                 if pair_count % 100000 == 0:
                     print(f"    ... {pair_count:,} pairs written")
 
     print(f"\n  Total pairs: {pair_count:,}")
+    print(f"  Loan-involved pairs: {loan_pair_count:,}")
+    print(f"  Purely inherited pairs: {inherited_pair_count:,}")
     print(f"  Output: {output_path}")
     print("=" * 60)
 

scripts/extract_wold_borrowings_v2.py

@@ -35,6 +35,29 @@ HEADER = (
 )
 
 
+def clean_source_word(raw: str) -> str:
+    """Clean a source word for pseudo-IPA use.
+
+    Strips parenthetical notes, proto-form asterisks, bracketed annotations,
+    and takes only the first alternative when multiple are separated by
+    comma, slash, or tilde.  Result is still pseudo-IPA (not real IPA) but
+    free of annotations that would produce garbage.
+    """
+    if not raw:
+        return ""
+    s = raw
+    # 1. Strip parenthetical notes: "(Written Tibetan)" etc.
+    s = re.sub(r"\([^)]*\)", "", s)
+    # 2. Strip bracketed annotations: "[loan]" etc.
+    s = re.sub(r"\[[^\]]*\]", "", s)
+    # 3. Strip proto-form leading asterisks
+    s = re.sub(r"^\*+", "", s.strip())
+    # 4. Take only first alternative (split on , / ~)
+    s = re.split(r"[,/~]", s)[0]
+    # 5. Strip whitespace and lowercase
+    return s.strip().lower()
+
+
 def segments_to_ipa(segments: str) -> str:
     """Convert CLDF Segments column to IPA string."""
     if not segments:
@@ -103,9 +126,10 @@ def main():
                 concept = row.get("Concepticon_Gloss", row.get("Name", pid)).strip()
                 param_concept[pid] = concept
 
-    # Step 3: Read forms.csv → Form_ID → {language, word, ipa, concept}
+    # Step 3: Read forms.csv → Form_ID → {language, word, ipa, concept} + Borrowed score
     forms_path = SOURCES_DIR / "forms.csv"
     forms = {}
+    form_borrowed: dict[str, str] = {}  # Form_ID → Borrowed score string
     with open(forms_path, "r", encoding="utf-8") as f:
         reader = csv.DictReader(f)
         for row in reader:
@@ -119,6 +143,8 @@ def main():
             ipa = segments_to_ipa(segments) if segments else form.lower()
             param_id = row.get("Parameter_ID", "").strip()
             concept = param_concept.get(param_id, param_id)
+            borrowed = row.get("Borrowed", "").strip()
+            form_borrowed[fid] = borrowed
             forms[fid] = {
                 "iso": iso,
                 "word": form,
@@ -133,6 +159,7 @@ def main():
     pair_count = 0
     skipped_no_target = 0
     skipped_no_source = 0
+    skipped_no_evidence = 0
 
     with open(output_path, "w", encoding="utf-8") as out:
         out.write(HEADER)
@@ -153,7 +180,14 @@ def main():
                     skipped_no_target += 1
                     continue
 
+                # Skip entries where target form has "no evidence for borrowing"
+                target_borrowed = form_borrowed.get(target_fid, "")
+                if target_borrowed.startswith("5"):
+                    skipped_no_evidence += 1
+                    continue
+
                 # Source can come from Source_Form_ID or Source_word
+                pseudo_ipa = False
                 if source_fid and source_fid in forms:
                     source = forms[source_fid]
                     source_iso = source["iso"]
@@ -162,39 +196,55 @@ def main():
                 elif source_word:
                     # Source form not in database — use Source_word + Source_languoid
                     source_iso = lang_name_to_iso.get(source_lang, "-")
-                    source_word_str = source_word
-                    source_ipa = source_word.lower()  # best-effort pseudo-IPA
+                    source_word_str = clean_source_word(source_word)
+                    source_ipa = source_word_str  # cleaned pseudo-IPA (not real IPA)
+                    pseudo_ipa = True
                 else:
                     skipped_no_source += 1
                     continue
 
-                # Donor language
-                donor_lang = source_iso if source_iso != "-" else source_lang
+                # Donor_Language: always use the WOLD language name (Source_languoid)
+                # for consistency. The field is a human-readable language name,
+                # NOT an ISO 639-3 code. Use source_iso (Lang_B) for the code.
+                donor_lang = source_lang if source_lang else "-"
 
                 # Confidence
                 confidence = "certain" if source_certain == "yes" else (
                     "uncertain" if source_certain == "no" else source_certain if source_certain else "-"
                 )
 
-                # Score
-                score = sca_similarity(target["ipa"], source_ipa)
+                # Score: -1 sentinel when source IPA is pseudo-IPA (cleaned
+                # orthography, not real IPA) — SCA similarity is unreliable
+                if pseudo_ipa:
+                    score = -1
+                else:
+                    score = sca_similarity(target["ipa"], source_ipa)
 
                 # Filter self-loans (same language borrowing from itself)
                 if target["iso"] == source_iso:
                     continue
 
+                # Relation_Detail: distinguish immediate vs earlier borrowings
+                if source_relation == "immediate":
+                    relation_detail = "borrowed_immediate"
+                elif source_relation == "earlier":
+                    relation_detail = "borrowed_earlier"
+                else:
+                    relation_detail = "borrowed"
+
                 # Lang_A = target (borrower), Lang_B = source (donor)
                 out.write(
                     f"{target['iso']}\t{target['word']}\t{target['ipa']}\t"
                     f"{source_iso}\t{source_word_str}\t{source_ipa}\t"
                     f"{target['concept']}\tborrowing\t{score}\twold\t"
-                    f"borrowed\t{donor_lang}\t{confidence}\twold_{borrowing_id}\n"
+                    f"{relation_detail}\t{donor_lang}\t{confidence}\twold_{borrowing_id}\n"
                 )
                 pair_count += 1
 
     print(f"\n  Total borrowing pairs: {pair_count:,}")
     print(f"  Skipped (no target form): {skipped_no_target}")
     print(f"  Skipped (no source info): {skipped_no_source}")
+    print(f"  Skipped (no evidence for borrowing): {skipped_no_evidence}")
     print(f"  Output: {output_path}")
     print("=" * 60)
 

scripts/merge_cognate_pairs.py

@@ -89,12 +89,29 @@ def main():
     print(f"  Total input rows: {total_input:,}")
     print(f"  Unique pairs: {len(seen_pairs):,}")
 
+    # Pass 1.5: Pre-populate inherited_lang_concepts from ALL expert_cognate
+    # entries across ALL files. This ensures concept_aligned and similarity_only
+    # pairs are correctly suppressed even when expert_cognate files are
+    # alphabetically after concept_aligned files.
+    print("\n  Pass 1.5: Collecting expert_cognate language-concept keys...")
+    inherited_lang_concepts: set[str] = set()
+    for sf in staging_files:
+        with open(sf, "r", encoding="utf-8") as f:
+            header = f.readline()
+            for line in f:
+                parts = line.rstrip("\n").split("\t")
+                if len(parts) < 8:
+                    continue
+                relationship = parts[7]
+                if relationship == "expert_cognate":
+                    la, lb = sorted([parts[0], parts[3]])
+                    concept = parts[6]
+                    inherited_lang_concepts.add(f"{la}||{lb}||{concept}")
+    print(f"  Expert language-concept keys: {len(inherited_lang_concepts):,}")
+
     # Second pass: write output files, keeping only best-priority entries
     print("\n  Pass 2: Writing output files...")
     written_keys: set[str] = set()
-    # Track (lang_pair, concept) combos that appear in inherited/borrowing
-    # to prevent the same language-concept pair from also appearing in similarity
-    inherited_lang_concepts: set[str] = set()
     counts = {"inherited": 0, "borrowing": 0, "similarity": 0}
     self_pair_skips = 0
 
@@ -137,20 +154,23 @@ def main():
                     lc_a, lc_b = sorted([lang_a, lang_b])
                     lang_concept_key = f"{lc_a}||{lc_b}||{concept}"
 
-                    written_keys.add(key)
-
                     # Route to correct output file
                     if relationship == "expert_cognate":
                         f_inh.write(line)
                         counts["inherited"] += 1
-                        inherited_lang_concepts.add(lang_concept_key)
+                        written_keys.add(key)
                     elif relationship == "borrowing":
                         f_bor.write(line)
                         counts["borrowing"] += 1
+                        written_keys.add(key)
                     elif relationship == "concept_aligned":
-                        f_inh.write(line)
-                        counts["inherited"] += 1
-                        inherited_lang_concepts.add(lang_concept_key)
+                        # concept_aligned goes to similarity (not inherited)
+                        # per PRD: expert cognates in inherited ONLY
+                        if lang_concept_key in inherited_lang_concepts:
+                            continue
+                        f_sim.write(line)
+                        counts["similarity"] += 1
+                        written_keys.add(key)
                     elif relationship == "similarity_only":
                         # Skip if this language-concept combo already
                         # has an inherited/expert pair (prevents cross-file
@@ -159,6 +179,7 @@ def main():
                             continue
                         f_sim.write(line)
                         counts["similarity"] += 1
+                        written_keys.add(key)
 
                     total_written = sum(counts.values())
                     if total_written % 1000000 == 0: