ltcai 11.7.0 → 12.0.0

package/lattice_brain/graph/_kg_common/normalize.py

@@ -0,0 +1,305 @@
+"""Entity-surface normalization and alias merge — deterministic, no model.
+
+Two concepts that are the same thing must become one node, or the graph
+answers "무엇이 무엇과 이어져 있나" with a fan of near-duplicates. Before
+v12.0.0 the only dedup was ``concept.text.lower()`` inside the Rust writer, so
+``"Lattice AI"`` / ``"lattice  ai"`` / ``"Lattice AI의"`` were three nodes.
+
+This module is the *surface* half of that fix, and it is deliberately boring:
+Unicode normalization, whitespace collapse, bracket/quote/punctuation trimming,
+English possessives, and Korean 조사 (postposition) stripping. No model, no
+network, no randomness — the same input always produces the same node id.
+
+## 조사 stripping, and why it is two tiers
+
+Korean marks grammatical role with a suffix glued to the noun, so the *same*
+entity appears as ``플랫폼은`` / ``플랫폼을`` / ``플랫폼에서``. Stripping the
+suffix is what merges them. But Korean nouns also legitimately *end* in those
+syllables — ``고양이`` ends in ``이``, ``전문가`` in ``가``, ``정확도`` in
+``도`` — and a blind strip invents ``고양`` / ``전문`` / ``정확``. That is worse
+than the duplicate it was trying to fix, because a wrong node id cannot be
+undone by a later read.
+
+So:
+
+* **Tier 1 — unconditional.** Multi-syllable particles (``에서``, ``으로``,
+  ``에게``, ``부터``, ``까지``, ``보다``, ``처럼`` …) plus ``을``/``를``.
+  Korean nouns essentially never end in these *as their own last syllables*
+  once a two-character stem is required, so no corroboration is needed.
+* **Tier 2 — evidence-gated.** The single-syllable particles that collide with
+  real noun endings (``은 는 이 가 의 와 과 도 로 만 나``) are stripped only
+  when the source text itself shows the bare stem somewhere else — that is,
+  the text contains the stem *not* followed by this particle. With no text to
+  corroborate (an LLM-supplied concept, say) nothing is stripped: an
+  unmerged duplicate is recoverable, an invented stem is not.
+
+Every stem must keep at least :data:`MIN_STEM_CHARS` characters, which by
+itself rejects the whole ``결과 → 결`` / ``회의 → 회`` class.
+"""
+
+from __future__ import annotations
+
+import functools
+import re
+import unicodedata
+from typing import Dict, Iterable, List, Sequence, Tuple
+
+#: A stripped stem shorter than this is never accepted — ``결과`` must not
+#: become ``결``. Two characters is the shortest real Korean noun stem.
+MIN_STEM_CHARS = 2
+
+#: Particles stripped without asking the text. Longest first: ``에서는`` has to
+#: be tried before ``에서`` or the leftover ``는`` stays glued on.
+UNCONDITIONAL_PARTICLES: Tuple[str, ...] = (
+    "에서는",
+    "으로는",
+    "에게는",
+    "로부터",
+    "이라는",
+    "이라고",
+    "에서도",
+    "으로도",
+    "에서의",
+    "으로서",
+    "으로써",
+    "에게서",
+    "에게도",
+    "라고는",
+    "만큼은",
+    "에서",
+    "에게",
+    "한테",
+    "께서",
+    "으로",
+    "부터",
+    "까지",
+    "보다",
+    "처럼",
+    "만큼",
+    "마다",
+    "조차",
+    "밖에",
+    "라는",
+    "라고",
+    "라도",
+    "이나",
+    "을",
+    "를",
+)
+
+#: Particles that collide with real noun endings — stripped only when the text
+#: shows the bare stem elsewhere (see :func:`strip_particle`).
+EVIDENCE_PARTICLES: Tuple[str, ...] = (
+    "은",
+    "는",
+    "이",
+    "가",
+    "의",
+    "와",
+    "과",
+    "도",
+    "로",
+    "만",
+    "나",
+)
+
+#: Opening → closing delimiters unwrapped when a term is wrapped in a *matched*
+#: pair. Matched only: ``<data_dir>/cloud_provider.json`` opens a bracket it
+#: never closes, and stripping the lone ``<`` invents a name nobody wrote.
+_DELIMITER_PAIRS = {
+    "(": ")",
+    "[": "]",
+    "{": "}",
+    "<": ">",
+    "«": "»",
+    "“": "”",
+    "‘": "’",
+    "「": "」",
+    "『": "』",
+    "《": "》",
+    "〈": "〉",
+    '"': '"',
+    "'": "'",
+    "`": "`",
+}
+#: Trailing punctuation trimmed after the brackets come off.
+_TRAILING_PUNCT = ".,;:!?…·~-–—/\\|"
+
+_WHITESPACE = re.compile(r"\s+")
+_HANGUL = re.compile(r"[가-힣]")
+_POSSESSIVE = re.compile(r"(?:['’]s|['’])$", re.IGNORECASE)
+
+
+def _is_hangul_tail(text: str) -> bool:
+    """True when the last character is a Hangul syllable."""
+    return bool(text) and bool(_HANGUL.fullmatch(text[-1]))
+
+
+def strip_particle(term: str, text: str = "") -> str:
+    """``term`` with one trailing Korean particle removed, when that is safe.
+
+    ``text`` is the passage the term came from; it is the corroboration for
+    the Tier-2 particles. Pass ``""`` and only Tier 1 fires.
+
+    >>> strip_particle("플랫폼에서")
+    '플랫폼'
+    >>> strip_particle("고양이")           # no evidence → left alone
+    '고양이'
+    >>> strip_particle("플랫폼이", "플랫폼이 있고 플랫폼도 있다")
+    '플랫폼'
+    """
+    term = term.strip()
+    if not _is_hangul_tail(term):
+        return term
+    for particle in UNCONDITIONAL_PARTICLES:
+        if term.endswith(particle):
+            stem = term[: -len(particle)]
+            if len(stem) >= MIN_STEM_CHARS and _is_hangul_tail(stem):
+                return stem
+    if not text:
+        return term
+    for particle in EVIDENCE_PARTICLES:
+        if not term.endswith(particle):
+            continue
+        stem = term[: -len(particle)]
+        if len(stem) < MIN_STEM_CHARS or not _is_hangul_tail(stem):
+            continue
+        if _stem_stands_alone(stem, particle, text):
+            return stem
+    return term
+
+
+@functools.lru_cache(maxsize=8192)
+def _stem_alone_re(stem: str, particle: str) -> re.Pattern[str]:
+    """Compiled ``stem`` not-followed-by ``particle`` look-ahead."""
+    return re.compile(re.escape(stem) + "(?!" + re.escape(particle) + ")")
+
+
+def _stem_stands_alone(stem: str, particle: str, text: str) -> bool:
+    """True when ``text`` contains ``stem`` *not* followed by ``particle``.
+
+    That is the whole evidence test: if the passage only ever writes
+    ``정확도``, the trailing ``도`` is part of the word. If it also writes
+    ``정확`` on its own (or ``정확을``, ``정확에서`` …), the ``도`` was a
+    particle after all.
+    """
+    return _stem_alone_re(stem, particle).search(text) is not None
+
+
+def normalize_entity(term: str, text: str = "") -> str:
+    """The canonical *surface* form of one extracted entity.
+
+    NFKC (so ``ＡＩ`` and ``AI`` are one word), whitespace collapsed to single
+    spaces, brackets/quotes/trailing punctuation trimmed, English possessive
+    dropped, and one Korean particle stripped when :func:`strip_particle`
+    considers it safe. Returns ``""`` for anything that normalizes away.
+
+    >>> normalize_entity("  “Lattice   AI”  ")
+    'Lattice AI'
+    >>> normalize_entity("Anthropic's")
+    'Anthropic'
+    >>> normalize_entity("지식그래프에서")
+    '지식그래프'
+    """
+    cleaned = unicodedata.normalize("NFKC", str(term or ""))
+    cleaned = _WHITESPACE.sub(" ", cleaned).strip()
+    # Matched wrappers come off, then trailing sentence punctuation; looped so
+    # `("Lattice AI").` unwraps fully rather than one layer at a time.
+    for _ in range(3):
+        before = cleaned
+        if len(cleaned) > 2 and cleaned.endswith(_DELIMITER_PAIRS.get(cleaned[0], "\0")):
+            cleaned = cleaned[1:-1].strip()
+        cleaned = cleaned.rstrip(_TRAILING_PUNCT).strip()
+        if cleaned == before:
+            break
+    if not cleaned:
+        return ""
+    cleaned = _POSSESSIVE.sub("", cleaned).strip()
+    return strip_particle(cleaned, text)
+
+
+def entity_key(term: str) -> str:
+    """The dedup key two surface forms of one entity share.
+
+    Case-folded and whitespace-collapsed, and with the separators that
+    identifier styles disagree about (space, ``-``, ``_``) removed — so
+    ``Graph RAG`` / ``graph-rag`` / ``graph_rag`` are one key while
+    ``GraphRAG`` (already joined) matches them too.
+    """
+    folded = unicodedata.normalize("NFKC", str(term or "")).casefold()
+    folded = _WHITESPACE.sub(" ", folded).strip()
+    return re.sub(r"[\s_\-]+", "", folded)
+
+
+def _representative(surfaces: Sequence[str], text: str) -> str:
+    """Pick the surface form an entity's node should carry.
+
+    Most frequent in the source text wins — the way the author actually writes
+    it. Ties go to the form with more capitalized words (``Lattice AI`` over
+    ``lattice ai``), then to the longer form, then to the first one seen, so
+    the choice never depends on dict ordering.
+    """
+    best = surfaces[0]
+    best_rank = (-1, -1, -1, 0)
+    for index, surface in enumerate(surfaces):
+        rank = (
+            text.count(surface) if text else 0,
+            sum(1 for word in surface.split() if word[:1].isupper()),
+            len(surface),
+            -index,
+        )
+        if rank > best_rank:
+            best_rank = rank
+            best = surface
+    return best
+
+
+def merge_entity_aliases(terms: Iterable[str], text: str = "") -> List[str]:
+    """Normalize every term, drop the empties, and merge exact-key aliases.
+
+    Order is the order the *first* member of each group appeared in, so the
+    caller's own priority (backticked terms first, then proper nouns, …) is
+    preserved. The value is the group's representative surface form.
+
+    >>> merge_entity_aliases(["Lattice AI", "lattice  ai", "Graph RAG"])
+    ['Lattice AI', 'Graph RAG']
+    """
+    groups: Dict[str, List[str]] = {}
+    order: List[str] = []
+    for term in terms:
+        surface = normalize_entity(term, text)
+        if not surface:
+            continue
+        key = entity_key(surface)
+        if not key:
+            continue
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        if surface not in groups[key]:
+            groups[key].append(surface)
+    return [_representative(groups[key], text) for key in order]
+
+
+def occurrence_count(term: str, text: str) -> int:
+    """How many times ``term`` appears in ``text``, case-insensitively.
+
+    The number an edge's ``occurrences`` metadata carries. Counted on the
+    normalized surface, so ``플랫폼은`` and ``플랫폼을`` both count toward
+    ``플랫폼``. Zero-length terms count zero rather than raising.
+    """
+    if not term or not text:
+        return 0
+    return len(re.findall(re.escape(term), text, re.IGNORECASE))
+
+
+__all__ = [
+    "EVIDENCE_PARTICLES",
+    "MIN_STEM_CHARS",
+    "UNCONDITIONAL_PARTICLES",
+    "entity_key",
+    "merge_entity_aliases",
+    "normalize_entity",
+    "occurrence_count",
+    "strip_particle",
+]

package/lattice_brain/graph/_kg_common/patterns.py

@@ -0,0 +1,275 @@
+"""Directed, typed relation patterns — the part of extraction that reads syntax.
+
+``infer_edge_relation`` classifies a *sentence*: it finds a verb anywhere in it
+and stamps every concept pair in that sentence with the same label, in text
+order. That is cheap and it is often wrong about **direction**, and it cannot
+tell a definition from a passing mention.
+
+The four rules here look at where each concept sits inside the sentence and at
+what stands *between* the two, so ``A는 B를 사용한다`` and ``B is used by A``
+come out with the same subject. Each rule returns the relation label the graph
+should carry, the evidence class, and a weight:
+
+| rule | label | `edges_v2` type | evidence | weight |
+|---|---|---|---|---|
+| definition | `설명함` | `MENTIONS` | `definition` | 1.0 |
+| SVO / SOV | the matched `EDGE_VERB` label | that label's type | `verb` | 1.0 |
+| part-of | `구성요소` | `PART_OF` | `structure` | 0.9 |
+| contrast | `상충함` | `CONTRADICTS` | `contrast` | 0.9 |
+
+``PART_OF`` and ``CONTRADICTS`` were reachable in the taxonomy but nothing
+extracted them; the graph only ever produced the ten labels `EDGE_VERB` names.
+
+Everything is regex over a single sentence — deterministic, no model, and the
+same input always yields the same edge.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from .relations import _EDGE_VERB_COMPILED
+
+#: Weight for a relation a syntactic pattern named outright.
+PATTERN_EDGE_WEIGHT = 0.9
+#: Weight for definition and verb-anchored relations — the strongest evidence.
+STRONG_EDGE_WEIGHT = 1.0
+
+#: `A is a B` / `A refers to B` — the copula and its cousins, English.
+_EN_DEFINITION = re.compile(
+    r"^\s*(?:is|are|was|were)\s+(?:a|an|the)?\s*$"
+    r"|^\s*(?:refers?\s+to|means?|stands\s+for|is\s+defined\s+as|is\s+known\s+as"
+    r"|is\s+short\s+for)\s*$",
+    re.IGNORECASE,
+)
+#: `A란 B이다` / `A는 B를 의미한다` — the Korean definition tail.
+_KO_DEFINITION_TAIL = re.compile(
+    r"(?:이다|입니다|이란다|이에요|예요|을 뜻한다|를 뜻한다|을 의미한다|를 의미한다"
+    r"|을 말한다|를 말한다|이라고 한다|라고 한다|이라 한다)\s*[.!?]?\s*$"
+)
+#: `A란`, `A이란`, `A라는 것은` — the Korean definition head marker. The
+#: lookbehind and the trailing space keep the bare ``란`` from matching the
+#: middle of an ordinary word (``결과란에``, ``발란스``).
+_KO_DEFINITION_HEAD = re.compile(
+    r"(?<=[가-힣])(?:이란|란|라는 것은|라 함은)\s|(?:의 정의는|정의는)\s"
+)
+
+#: `A is part of B` — part first, whole second.
+_EN_PART_FORWARD = re.compile(
+    r"^\s*(?:is|are|was|were)?\s*(?:a|an|the)?\s*"
+    r"(?:part\s+of|component\s+of|subset\s+of|member\s+of|belongs?\s+to"
+    r"|lives?\s+(?:in|under)|sits?\s+(?:in|under))\s*$",
+    re.IGNORECASE,
+)
+#: `B consists of A` — whole first, part second, so the edge is reversed.
+#: ``contains``/``includes`` are deliberately **not** here: they already route
+#: to `포함함` → `CONTAINS`, which is the right edge pointing the right way.
+_EN_PART_REVERSE = re.compile(
+    r"^\s*(?:consists?\s+of|comprises?|is\s+made\s+(?:up\s+)?of)\s*$",
+    re.IGNORECASE,
+)
+#: `A는 B의 일부` / `A는 B에 속한다` — part first, whole second.
+_KO_PART_FORWARD = re.compile(r"(?:의 일부|의 구성요소|의 하위|에 속한|에 포함된|의 부분)")
+#: `A는 B로 구성된다` — whole first, part second.
+_KO_PART_REVERSE = re.compile(r"(?:로 구성|으로 구성|의 하위 항목)")
+
+#: `A unlike B` / `A instead of B` — a stated opposition, not a comparison.
+_EN_CONTRAST = re.compile(
+    r"(?:\bunlike\b|\binstead\s+of\b|\brather\s+than\b|\bcontrary\s+to\b"
+    r"|\bas\s+opposed\s+to\b|\bnot\b[^.]{0,20}\bbut\b)",
+    re.IGNORECASE,
+)
+#: `A가 아니라 B` / `A 대신 B` / `A와 달리 B`.
+_KO_CONTRAST = re.compile(r"(?:아니라|아닌|대신|와 달리|과 달리|반면|이 아니고|가 아니고)")
+
+#: Subject markers: the syllable that says "this noun is the actor".
+_KO_SUBJECT_MARKS: Tuple[str, ...] = ("은", "는", "이", "가", "께서")
+#: Object markers: the syllable that says "this noun is acted on".
+_KO_OBJECT_MARKS: Tuple[str, ...] = ("을", "를")
+
+
+def _marker_after(sentence: str, end: int, markers: Sequence[str]) -> bool:
+    """True when one of ``markers`` sits immediately after ``end``.
+
+    Korean glues the particle to the noun with no space, so a single lookahead
+    character is the whole test.
+    """
+    tail = sentence[end : end + 2]
+    return any(tail.startswith(mark) for mark in markers)
+
+
+def _verb_label(span: str) -> Optional[str]:
+    """The `EDGE_VERB` label whose pattern matches ``span``, if any."""
+    lowered = span.lower()
+    for label, pattern in _EDGE_VERB_COMPILED:
+        if pattern.search(lowered):
+            return label
+    return None
+
+
+def _triple(
+    subject: str,
+    obj: str,
+    relation: str,
+    evidence: str,
+    weight: float,
+    context: str,
+) -> Dict[str, Any]:
+    return {
+        "subject": subject,
+        "relation": relation,
+        "object": obj,
+        "context": context[:240],
+        "evidence": evidence,
+        "weight": weight,
+    }
+
+
+def concept_positions(
+    sentence: str, concepts: Sequence[str]
+) -> List[Tuple[int, str]]:
+    """``(offset, concept)`` for every concept present, in text order.
+
+    Case-insensitive, first occurrence only — a concept repeated in one
+    sentence is one participant, not two.
+    """
+    lowered = sentence.lower()
+    found: List[Tuple[int, str]] = []
+    for concept in concepts:
+        index = lowered.find(concept.lower())
+        if index >= 0:
+            found.append((index, concept))
+    found.sort(key=lambda pair: (pair[0], pair[1]))
+    return found
+
+
+def typed_relation(
+    sentence: str,
+    left: Tuple[int, str],
+    right: Tuple[int, str],
+    adjacent: bool = True,
+) -> Optional[Dict[str, Any]]:
+    """The typed, directed relation between two concepts in one sentence.
+
+    ``left``/``right`` are ``(offset, concept)`` with ``left`` first in the
+    text. Returns ``None`` when no rule fires, which is the caller's signal to
+    fall back to the sentence-level co-occurrence classification.
+
+    ``adjacent=False`` means another concept sits between the two, and then
+    only the particle-marked Korean subject→object rule may fire. Everything
+    else reads the span *between* the pair, and with a third concept in there
+    that span describes somebody else's relation: ``A는 B가 아니라 C를 쓴다``
+    puts ``아니라`` between A and C without A and C being in contrast at all.
+    """
+    left_at, subject = left
+    right_at, obj = right
+    between = sentence[left_at + len(subject) : right_at]
+    after = sentence[right_at + len(obj) :]
+
+    if not adjacent:
+        return _korean_subject_object(sentence, subject, obj, after, left_at, right_at)
+
+    definition = _definition(sentence, between, subject, obj)
+    if definition is not None:
+        return definition
+    part_of = _part_of(between, after, subject, obj, sentence)
+    if part_of is not None:
+        return part_of
+    contrast = _contrast(between, subject, obj, sentence)
+    if contrast is not None:
+        return contrast
+    return _verb_anchored(sentence, subject, obj, between, after, left_at, right_at)
+
+
+def _definition(
+    sentence: str, between: str, subject: str, obj: str
+) -> Optional[Dict[str, Any]]:
+    english = _EN_DEFINITION.match(between)
+    korean = bool(_KO_DEFINITION_TAIL.search(sentence)) and bool(
+        _KO_DEFINITION_HEAD.search(sentence)
+    )
+    if not english and not korean:
+        return None
+    return _triple(
+        subject, obj, "설명함", "definition", STRONG_EDGE_WEIGHT, sentence
+    )
+
+
+def _part_of(
+    between: str, after: str, subject: str, obj: str, sentence: str
+) -> Optional[Dict[str, Any]]:
+    # English states the relation *between* the two ("A is part of B"); Korean
+    # glues it to the second one ("A는 B의 일부이다"), so the tail is read too —
+    # anchored at position zero, because the marker belongs to the noun it is
+    # stuck to. A match further along the tail is some *other* noun's relation.
+    if _EN_PART_FORWARD.match(between) or _KO_PART_FORWARD.match(after):
+        return _triple(
+            subject, obj, "구성요소", "structure", PATTERN_EDGE_WEIGHT, sentence
+        )
+    if _EN_PART_REVERSE.match(between) or _KO_PART_REVERSE.match(after):
+        # `B consists of A` — the *whole* was named first, so the part-of edge
+        # points the other way. Direction is the whole point of this module.
+        return _triple(
+            obj, subject, "구성요소", "structure", PATTERN_EDGE_WEIGHT, sentence
+        )
+    return None
+
+
+def _contrast(
+    between: str, subject: str, obj: str, sentence: str
+) -> Optional[Dict[str, Any]]:
+    if _EN_CONTRAST.search(between) or _KO_CONTRAST.search(between):
+        return _triple(
+            subject, obj, "상충함", "contrast", PATTERN_EDGE_WEIGHT, sentence
+        )
+    return None
+
+
+def _verb_anchored(
+    sentence: str,
+    subject: str,
+    obj: str,
+    between: str,
+    after: str,
+    left_at: int,
+    right_at: int,
+) -> Optional[Dict[str, Any]]:
+    """A verb that sits *between* the pair (SVO) or *after* it (Korean SOV).
+
+    English puts the verb between subject and object, so ``between`` naming a
+    verb is enough. Korean puts it last: the direction comes from the particles
+    instead — ``A는 … B를 사용한다`` marks A as subject and B as object, and the
+    verb in the tail names the relation.
+    """
+    label = _verb_label(between)
+    if label is not None:
+        return _triple(subject, obj, label, "verb", STRONG_EDGE_WEIGHT, sentence)
+    return _korean_subject_object(sentence, subject, obj, after, left_at, right_at)
+
+
+def _korean_subject_object(
+    sentence: str,
+    subject: str,
+    obj: str,
+    after: str,
+    left_at: int,
+    right_at: int,
+) -> Optional[Dict[str, Any]]:
+    """``A는 … B를 <verb>`` — the particles decide, the tail verb names it."""
+    subject_marked = _marker_after(sentence, left_at + len(subject), _KO_SUBJECT_MARKS)
+    object_marked = _marker_after(sentence, right_at + len(obj), _KO_OBJECT_MARKS)
+    if not (subject_marked and object_marked):
+        return None
+    tail_label = _verb_label(after)
+    if tail_label is None:
+        return None
+    return _triple(subject, obj, tail_label, "verb", STRONG_EDGE_WEIGHT, sentence)
+
+
+__all__ = [
+    "PATTERN_EDGE_WEIGHT",
+    "STRONG_EDGE_WEIGHT",
+    "concept_positions",
+    "typed_relation",
+]

package/lattice_brain/graph/_kg_common/relations.py

@@ -32,7 +32,9 @@ EDGE_VERB = {
     "의존함": r"의존|depend|require|필요|based on",
     "설명함": r"설명|explain|describe|정의|란|이란|means",
     "비교함": r"비교|versus|vs\.?|차이|다르|compare",
-    "사용함": r"사용|use|활용|이용|apply",
+    # `쓴다`/`쓰는`/`씁니다` are the everyday Korean for "uses"; without them a
+    # sentence that never says 사용 fell through to bare co-occurrence.
+    "사용함": r"사용|use|활용|이용|apply|쓴다|쓰는|씁니다|썼다",
     "연결함": r"연결|connect|통합|integrate|연동|link",
     "확장함": r"확장|extend|플러그인|plugin|addon",
     "생성함": r"생성|만들|create|generate|build|produced",
@@ -42,6 +44,13 @@ EDGE_VERB = {
     "관련됨": r"관련|related|associated|연관",
 }
 
+#: Same table, compiled once. ``infer_edge_relation`` and the typed-relation
+#: patterns both walk this on every pair; compiling per call was the cheap
+#: half of the extraction regression.
+_EDGE_VERB_COMPILED = tuple(
+    (label, re.compile(pattern)) for label, pattern in EDGE_VERB.items()
+)
+
 
 # Concepts in a list-like sentence ("A, B, C, D를 사용한다") sit together by
 # enumeration, not by relation. Beyond this many concepts in one sentence, a
@@ -70,8 +79,8 @@ def infer_edge_relation(sentence: str) -> Dict[str, Any]:
     label-only output erased.
     """
     s = str(sentence or "").lower()
-    for label, pattern in EDGE_VERB.items():
-        if re.search(pattern, s):
+    for label, pattern in _EDGE_VERB_COMPILED:
+        if pattern.search(s):
             # "관련됨" is itself a weak, generic label: matching it by keyword
             # ("관련", "related") is still verb evidence, but nothing stronger.
             return {