"""Per-claim grounding features. Deliberately classical so they re-implement cleanly in JS. The claim is scored against the source using lexical support signals: overlap, fuzzy match, number/entity support, novel-content ratio, and a contradiction signal. """ from __future__ import annotations import re STOP = set("a an the of to in on at for and or but with by from as is are was were be been being " "it its this that these those they them their he she his her you your we our i me my " "has have had do does did will would can could should may might must not no " "about over under into out up down off than then so such also just only very more most " "which who whom whose what when where why how".split()) NEG = set("not no never none cannot can't don't doesn't didn't won't isn't aren't wasn't weren't " "without fell dropped declined fewer less lower nothing failed".split()) FEATURE_NAMES = [ "tok_jaccard_doc", "tok_recall_doc", "best_sent_jaccard", "best_sent_recall", "fuzzy_best", "fuzzy_doc", "number_support", "entity_support", "novel_content_ratio", "contradiction_signal", "has_number", "has_entity", "claim_len_tokens", "n_source_sents", ] def sentences(text: str): return [s.strip() for s in re.split(r"(?<=[.!?])\s+", text.strip()) if s.strip()] def content_tokens(text: str): toks = re.findall(r"[a-z0-9]+", text.lower()) return [t for t in toks if t not in STOP and len(t) > 1] def numbers(text: str): # standalone integers / decimals, ignoring those glued inside words return set(re.findall(r"(? float: if not a and not b: return 0.0 return len(a & b) / len(a | b) if (a | b) else 0.0 def _recall(a: set, b: set) -> float: # fraction of a's tokens present in b return len(a & b) / len(a) if a else 0.0 def _bigrams(s: str): s = s.lower() return [s[i:i+2] for i in range(len(s) - 1)] def _fuzzy(a: str, b: str) -> float: # char-bigram Dice coefficient; deterministic and trivially portable to JS A, B = _bigrams(a), _bigrams(b) if not A or not B: return 0.0 from collections import Counter ca, cb = Counter(A), Counter(B) inter = sum((ca & cb).values()) return 2 * inter / (len(A) + len(B)) def features(claim: str, source: str) -> list[float]: src_sents = sentences(source) claim_tok = set(content_tokens(claim)) doc_tok = set(content_tokens(source)) f = [] f.append(_jaccard(claim_tok, doc_tok)) # tok_jaccard_doc f.append(_recall(claim_tok, doc_tok)) # tok_recall_doc best_j = best_r = 0.0 best_fuzzy = 0.0 best_sent = "" for s in src_sents: st = set(content_tokens(s)) j = _jaccard(claim_tok, st) r = _recall(claim_tok, st) if r > best_r or (r == best_r and j > best_j): best_r, best_j, best_sent = r, j, s best_fuzzy = max(best_fuzzy, _fuzzy(claim, s)) f.append(best_j) # best_sent_jaccard f.append(best_r) # best_sent_recall f.append(best_fuzzy) # fuzzy_best f.append(_fuzzy(claim, source)) # fuzzy_doc cnums, dnums = numbers_norm(claim), numbers_norm(source) f.append(1.0 if not cnums else len(cnums & dnums) / len(cnums)) # number_support cent, dent = entities(claim), entities(source) f.append(1.0 if not cent else len(cent & dent) / len(cent)) # entity_support f.append(1.0 - _recall(claim_tok, doc_tok)) # novel_content_ratio # contradiction: claim has a negation token that its best-match source sentence lacks (or vice-versa) claim_neg = bool(set(re.findall(r"[a-z']+", claim.lower())) & NEG) best_neg = bool(set(re.findall(r"[a-z']+", best_sent.lower())) & NEG) f.append(1.0 if claim_neg != best_neg else 0.0) # contradiction_signal f.append(1.0 if cnums else 0.0) # has_number f.append(1.0 if cent else 0.0) # has_entity f.append(float(len(claim_tok))) # claim_len_tokens f.append(float(len(src_sents))) # n_source_sents return f