old-storage-backup / ar_pairs /cleaned /codes /_reference_verification.py
canho's picture
Add files using upload-large-folder tool
ae728b3 verified
Raw History Blame Contribute Delete
13 kB
#!/usr/bin/env python3
"""Verify Semantic Scholar reference links against the base paper's own bibliography (no LLM).
1. Fetch the base paper's open PDF (reuses fulltext.FullTextClient; arXiv/ACL Anthology PDFs).
2. Locate the References section and split it into entries with regexes
(author-year styles such as ACL/AAAI, and numeric "[12]" styles).
3. Extract each entry's year and title.
4. For every target returned by Semantic Scholar /references, compute the S2ORC title
similarity (harmonic mean of Jaccard and containment over character 3-grams of the
normalized title) against all parsed entries. A link is VERIFIED if the best score
is >= 0.8 (S2ORC's threshold).
Outputs per-base parse stats and per-target verification records.
"""
import re
YEAR = r'(?:19|20)\d{2}[a-z]?'
def norm_title(t):
return re.sub(r'[^a-z0-9]', '', (t or '').lower())
def grams(s, n=3):
return {s[i:i + n] for i in range(len(s) - n + 1)} if len(s) >= n else {s}
def containment(title, entry_text):
"""Share of the title's character 3-grams found in the entry text; guards against very short titles."""
A = grams(norm_title(title))
if len(norm_title(title)) < 20 or not A:
return 0.0
return len(A & grams(norm_title(entry_text))) / len(A)
def s2orc_sim(a, b):
A, B = grams(norm_title(a)), grams(norm_title(b))
if not A or not B:
return 0.0
inter = len(A & B)
j = inter / len(A | B)
c = inter / min(len(A), len(B))
return 0.0 if j + c == 0 else 2 * j * c / (j + c)
def column_blocks(pdf_path):
"""Text blocks in reading order for 1- or 2-column pages (used for body text)."""
import pymupdf
blocks = []
with pymupdf.open(pdf_path) as doc:
for pno, page in enumerate(doc):
mid = page.rect.width / 2
raw = [b for b in page.get_text('blocks') if b[6] == 0 and b[4].strip()]
two_col = sum((b[2] - b[0]) < mid * 1.1 for b in raw) > 0.6 * max(len(raw), 1)
for b in raw:
col = (0 if not two_col else (0 if b[0] < mid - 20 else 1))
blocks.append((pno, col, b[1], re.sub(r'-\n(?=[a-z])', '', b[4]).replace('\n', ' ').strip()))
blocks.sort(key=lambda x: (x[0], x[1], x[2]))
return [t for *_, t in blocks]
def column_lines(pdf_path):
"""Individual text lines with x0, in reading order: (page, col, y0, x0, text)."""
import pymupdf
lines = []
with pymupdf.open(pdf_path) as doc:
for pno, page in enumerate(doc):
mid = page.rect.width / 2
d = page.get_text('dict')
blocks = [b for b in d['blocks'] if b.get('type') == 0]
two_col = sum((b['bbox'][2] - b['bbox'][0]) < mid * 1.1 for b in blocks) > 0.6 * max(len(blocks), 1)
for b in blocks:
for ln in b['lines']:
text = ''.join(sp['text'] for sp in ln['spans']).strip()
if not text:
continue
x0, y0 = ln['bbox'][0], ln['bbox'][1]
col = 0 if not two_col else (0 if x0 < mid - 20 else 1)
lines.append((pno, col, y0, x0, text))
lines.sort(key=lambda x: (x[0], x[1], x[2]))
return lines
NAME_RE = r"[A-Z][\w'’\-\.]*"
AUTHOR_RE = r"(?:%s\s+){1,4}[A-Z][\w'’\-]+" % NAME_RE
# A record boundary: preceded by a sentence end that is NOT an initial ("M. E. J. Newman"), followed by an author
# list whose first token is a full first name (2+ letters), then ". YEAR. ".
FIRSTNAME_RE = r"[A-Z][a-z][\w'’\-]*"
FIRST_AUTHOR_RE = r"%s(?:\s+%s){0,3}\s+[A-Z][\w'’\-]+" % (FIRSTNAME_RE, NAME_RE)
AUTHORS_YEAR_RE = re.compile(r"(?<=[.)\]] )(?<![A-Z]\. )(%s(?:,\s+%s)*(?:,?\s+and\s+%s)?\.\s(?:19|20)\d{2}[a-z]?\.\s)" % (FIRST_AUTHOR_RE, AUTHOR_RE, AUTHOR_RE))
def split_merged_author_year(entry):
"""If several 'Authors. YEAR. Title...' records were merged into one entry, split them."""
starts = [mm.start(1) for mm in AUTHORS_YEAR_RE.finditer(entry)]
starts = [s for s in starts if s > 20]
if not starts:
return [entry]
cuts = [0] + starts + [len(entry)]
return [entry[a:b].strip() for a, b in zip(cuts, cuts[1:]) if entry[a:b].strip()]
def reference_entries(pdf_path):
"""Segment the References section into entries using hanging indents / numeric labels.
An entry starts on a line whose x0 sits at the column's left margin (continuation
lines are indented), or on a line beginning with "[n]" / "n." labels.
"""
lines = column_lines(pdf_path)
HEAD = r'(References|REFERENCES|Reference List|Bibliography|BIBLIOGRAPHY|Literature Cited|LITERATURE CITED|Works Cited|References and Notes|REFERENCES AND NOTES|Notes and References|Referencias|REFERENCIAS|Referências|REFERÊNCIAS|Bibliografía|BIBLIOGRAFÍA|Bibliografia|BIBLIOGRAFIA|Literatur|LITERATUR|Literaturverzeichnis|Bibliographie|BIBLIOGRAPHIE|Références|RÉFÉRENCES|Referensi|REFERENSI|Daftar Pustaka|DAFTAR PUSTAKA|Literatura Citada|LITERATURA CITADA|Riferimenti bibliografici)'
heads = [i for i, l in enumerate(lines) if re.fullmatch(r'\s*(?:\d{1,2}\.?\s+)?' + HEAD + r'\s*[:.]?\s*', l[4])] # v2 (2026-09-26): multilingual headings, optional numbering/colon
if not heads:
return None, None
region = []
for l in lines[heads[-1] + 1:]:
t = l[4]
if re.match(r'\s*(Appendix|APPENDIX|Appendices|Supplementary Material|Supplemental Material|Ethics Statement|Ethical Considerations|Limitations)\b', t) and len(t) < 60:
break
if re.fullmatch(r'\s*[A-Z]\s{1,3}[A-Z][A-Za-z ,:\-]{3,60}', t): # "A Additional Results" style appendix heading
break
# v4 (2026-10-05): "A Proof of Theorem 1" / "A.1 Lemmas" appendix headings (single space, no year) after the list
if region and len(t) < 70 and not re.search(YEAR, t) and re.fullmatch(r'\s*(?:[A-Z]|[A-Z]\.\d{1,2})\s+[A-Z][a-z]{2,}[\w ,:\-]*', t):
break
if re.fullmatch(r'\s*\d{1,5}\s*', t):
continue # page number
region.append(l)
if not region:
return [], 'unknown'
# Left margin per (page, column): the smallest x0 that at least two lines share (within 1.5pt).
margins = {}
for key in {(l[0], l[1]) for l in region}:
xs = sorted(l[3] for l in region if (l[0], l[1]) == key)
margins[key] = min(xs)
entries, cur = [], ''
margin_starts = sum((l[3] - margins[(l[0], l[1])]) < 3.0 for l in region)
numeric_labels = sum(bool(re.match(r'\[\d{1,3}\]', l[4])) for l in region)
lncs_labels = sum(bool(re.match(r'\d{1,3}\.\s+[A-Z]', l[4])) for l in region) # v2: any capitalised start ("1. Hayes JD, ..." biomedical lists), not only "Surname,"
# v4 (2026-10-05): labels that run 1, 2, 3, ... define the entries even when margin statistics are off (appendix pages after the
# list, a stray line left of the labels); checked before the margin test below.
def _sequential(rx):
nums = [int(m.group(1)) for m in (re.match(rx, l[4]) for l in region) if m]
return len(nums) >= 5 and sum(b == a + 1 for a, b in zip(nums, nums[1:])) >= 0.8 * (len(nums) - 1)
seq_numeric, seq_lncs = _sequential(r'\[(\d{1,3})\]'), _sequential(r'(\d{1,3})\.\s+[A-Z]')
# Labels define entries only when they account for most margin-aligned lines.
if numeric_labels < 0.5 * max(margin_starts, 1) and not seq_numeric:
numeric_labels = 0
if lncs_labels < 0.5 * max(margin_starts, 1) and not seq_lncs:
lncs_labels = 0
for l in region:
t = l[4]
is_start = (l[3] - margins[(l[0], l[1])]) < 3.0
if numeric_labels >= 5:
is_start = bool(re.match(r'\[\d{1,3}\]', t))
elif lncs_labels >= 5:
is_start = bool(re.match(r'\d{1,3}\.\s+[A-Z]', t))
if is_start and cur:
entries.append(cur); cur = t
else:
cur = (cur[:-1] + t) if cur.endswith('-') and t[:1].islower() else (cur + ' ' + t if cur else t)
if cur:
entries.append(cur)
entries = [re.sub(r'\s+', ' ', e).strip() for e in entries if re.search(YEAR, e)]
style = 'numeric' if numeric_labels >= 5 else 'lncs' if lncs_labels >= 5 else 'author-year'
# v3 (2026-10-05): NeurIPS-style "[n]" labels whose continuation lines align with the label start every margin line, so the
# line-count test above misses them; decide on the segmented entries instead.
if style == 'author-year' and len(entries) >= 5 and sum(bool(re.match(r'\[\d{1,3}\]', e)) for e in entries) >= 0.6 * len(entries):
style = 'numeric'
# v4 (2026-10-05): MDPI-style "1." labels sit on their own line, so the line test above misses them; decide on the entries.
if style == 'author-year' and len(entries) >= 5 and sum(bool(re.match(r'\d{1,3}\.\s+\S', e)) for e in entries) >= 0.6 * len(entries):
style = 'lncs'
if style == 'author-year':
entries = [part for e in entries for part in split_merged_author_year(e)]
if style == 'author-year' and len(re.findall(r', ' + YEAR + r'\.$', ' '.join(e[-12:] for e in entries))) > 0.5 * len(entries):
style = 'year-end'
return entries, style
QUOTED_TITLE = re.compile(r'(?:‘‘|“|``|"|«)\s*(.{8,400}?)\s*[,.]?\s*(?:’’|”|\'\'|"|»)')
def parse_entry(e):
"""v4 (2026-10-05): a title in typographic quotes (IEEE ‘‘Title,’’, APA-like “Title”) is taken as the title first."""
r = _parse_entry(e)
qm = QUOTED_TITLE.search(e)
if r is not None and qm:
r['title'] = qm.group(1).strip().rstrip(',.')
return r
def _parse_entry(e):
mm = re.search(r'\.\s(' + YEAR + r')\.\s(.+)', e)
lm = re.match(r'\d{1,3}\. (.+?): (.+)', e) # LNCS: "n. Authors: Title. In: ..."
if lm and not mm:
ym = re.search(r'\((' + YEAR + r')\)|\b(' + YEAR + r')\b', e)
year = (ym.group(1) or ym.group(2)) if ym else '0000'
rest = lm.group(2)
elif mm:
year, rest = mm.group(1), mm.group(2)
else:
mm = re.search(r'\((' + YEAR + r')\)\.?\s(.+)', e)
if mm:
year, rest = mm.group(1), mm.group(2)
else:
ym = re.search(r'\b(' + YEAR + r')\b', e)
if not ym:
return None
year = ym.group(1)
# Year-at-end style: title follows the author block ("... and S. Sanghai. Title. Venue, 2023.")
am = re.search(r'(?:[A-Z]\.|[A-Z][a-z]+)\.\s+(?=[A-Z])', e)
rest = e[am.end():] if am else e
# Title = up to the first period followed by a space and a venue-ish token.
tm = re.match(r'(.+?[.?!])\s(?=(?:In |Proceedings|Proc\.|arXiv|Journal|Trans\.|IEEE|ACM|[A-Z][a-z]+ (?:of|for|on) |[A-Z][A-Za-z]+(?:,|\s\d)|\d))', rest)
title = (tm.group(1) if tm else rest.split('. ')[0]).strip().rstrip('.')
return {'year': int(year[:4]) if year[:4].isdigit() else 0, 'title': title, 'raw': e[:300], 'raw_full': e}
def in_text_match(contexts, target):
"""Secondary check: do any (Surname, Year) markers in the citing sentences match the target record?"""
cites = re.findall(r'\(([^()]*?' + YEAR + r')\)', ' '.join(contexts))
if not cites:
return None
surnames = {a['name'].split()[-1].lower() for a in (target.get('authors') or []) if a.get('name')}
y = target.get('year') or 0
for grp in cites:
for c in grp.split(';'):
sm = re.match(r'\s*([A-Z][A-Za-z\-\'’]+)', c.strip()); ym = re.search(r'(\d{4})', c)
if sm and ym and sm.group(1).lower() in surnames and abs(int(ym.group(1)) - y) <= 2:
return True
return False
def author_year_match(entry, target, year_tol=2):
"""Metadata check on top of the title match: the Semantic Scholar record's author surname(s) must appear in the
reference entry text, and the entry year must be within `year_tol` of the record year. Catches records whose
title matches but that point to a different work (e.g. two textbooks both titled "Convex Optimization").
Returns (author_ok, year_ok); author_ok is None when the record lists no authors."""
if entry is None:
return None, None
text = (entry.get('raw_full') or entry.get('raw') or '').lower()
surnames = [a['name'].split()[-1].lower() for a in (target.get('authors') or []) if a.get('name') and len(a['name'].split()[-1]) > 1]
author_ok = None if not surnames else any(re.search(r'\b' + re.escape(sn) + r'\b', text) for sn in surnames)
ey, ty = entry.get('year') or 0, target.get('year') or 0
year_ok = None if not (ey and ty) else abs(ey - ty) <= year_tol
return author_ok, year_ok
def link_status(title_ok, author_ok, year_ok):
"""verified = title matches and neither author nor year contradicts the record.
metadata_mismatch = title matches but author or year contradicts (record likely points at a different work)."""
if not title_ok:
return 'unverified'
if author_ok is False or year_ok is False:
return 'metadata_mismatch'
return 'verified'