ref-verify 1.1.2__tar.gz → 1.2.0__tar.gz

{ref_verify-1.1.2/src/ref_verify.egg-info → ref_verify-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ref-verify
-Version: 1.1.2
+Version: 1.2.0
 Summary: Executable DOI and claim verification helpers for academic citations
 Author: Moonweave Research
 License-Expression: MIT
@@ -45,6 +45,8 @@ Works with **Claude Code, Cursor, Codex**, and any agent that supports the
 
 After installation, use it like a normal agent skill. You do not start a server and you do not configure MCP for this workflow. No MCP server is required for this workflow.
 
+For explicit agent tool-calling rules, see [AGENT_USAGE.md](https://github.com/Moonweave-Research/ref-verify/blob/main/AGENT_USAGE.md).
+
 ---
 
 ## Use it
@@ -75,10 +77,11 @@ checks that are currently safe to automate directly:
 
 - CrossRef metadata check: `ref-verify verify-doi`
 - DOI-bound abstract claim check: `ref-verify check-claim`
+- Batch DOI-bound claim checks: `ref-verify check-file`
   - literal text claims
   - subject-matched percentage claims such as efficiency, response rate, or actuation strain
   - simple unit/count claims such as cycles, patients, voltage, temperature, and concentration
-  - CrossRef first, then DOI-bound Semantic Scholar and PubMed fallback when CrossRef has no abstract
+  - CrossRef first, then DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback when CrossRef has no abstract
 - JSON output for agent-readable routing
 - Non-zero exit codes for `WARN`, `REJECT`, and `UNVERIFIABLE` results
 
@@ -86,7 +89,7 @@ Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ra
 
 The CLI has zero third-party Python runtime dependencies, but it is not an
 offline verifier. Functional checks require outbound HTTPS access to public
-academic APIs such as CrossRef, Semantic Scholar, and PubMed.
+academic APIs such as CrossRef, OpenAlex, Semantic Scholar, and PubMed.
 
 Install the CLI from a local checkout:
 
@@ -127,7 +130,7 @@ ref-verify check-claim 10.1126/science.287.5454.836 \
   --json
 ```
 
-By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound Semantic Scholar and PubMed fallback sources. Use `--source crossref`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
+By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback sources. Use `--source crossref`, `--source openalex`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
 
 Source-checkout equivalents:
 
@@ -169,6 +172,44 @@ normal CI does not fail because an upstream API is temporarily unavailable.
 
 ---
 
+## Scope — what it does and does not verify
+
+`ref-verify` is a conservative guard, not an oracle. It errs toward flagging: an
+`ACCEPT` is high-confidence, and **anything else means "not auto-verifiable —
+check it yourself", not "the citation is wrong."**
+
+**It verifies**
+
+- DOI metadata: title, first-author surname, and year against CrossRef.
+- Whether a DOI-bound **abstract** explicitly supports a specific numeric or
+  literal claim, quoted verbatim. If no abstract is reachable, it returns
+  `UNVERIFIABLE` rather than guessing.
+
+**It does not verify** (out of scope by design, not bugs)
+
+- **Full-text, figure, table, or supplementary values** — abstract-only. A number
+  that appears only in the body stays `UNVERIFIABLE`.
+- **Relational or qualitative claims** — proportionalities, mechanisms,
+  "broader/stronger than". Only value+unit and literal claims are checked.
+- **Papers whose publisher withholds the abstract** — some titles expose no
+  abstract to CrossRef or OpenAlex. No abstract → `UNVERIFIABLE`, which reflects
+  reachability, not the claim.
+- **Statistical metrics** (p-value, AUC/AUROC, F1, hazard/odds ratio, confidence
+  intervals) — handled by the manual skill protocol, not the CLI.
+- **Paper quality, novelty, field consensus**, or whether the *full* paper
+  supports a broader statement.
+
+**Reading a verdict**
+
+| Verdict | Meaning |
+|---|---|
+| `ACCEPT` | The fetched abstract explicitly supports the claim. High-confidence pass. |
+| `WARN` / `PARTIAL` | An abstract was read but does not explicitly support the exact claim. Check the source. |
+| `UNVERIFIABLE` | No abstract was reachable to check against. Not a judgment on the claim. |
+| `REJECT` | DOI is dead, resolves to a different paper, contradicted, or retracted. |
+
+---
+
 ## Modes
 
 **Quick Screen** is for DOIs you already have. It uses CrossRef to compare the
@@ -182,8 +223,8 @@ ref-verify verify-doi <doi> --title "<title>" --first-author <last-name> --year
 exit code, so weak or mismatched metadata cannot silently pass automation gates.
 
 **Full Audit** is for literature search and final pre-submission review. The
-skill fetches abstracts through CrossRef, Semantic Scholar, Unpaywall, arXiv,
-and PubMed where needed, then checks whether the paper supports the specific
+skill fetches abstracts through CrossRef, OpenAlex, Semantic Scholar, Unpaywall,
+arXiv, and PubMed where needed, then checks whether the paper supports the specific
 claim being cited.
 
 For a single DOI-backed claim, the CLI can run the abstract check:
@@ -197,6 +238,28 @@ ref-verify check-claim <doi> --claim "<specific claim>" --json
 `abstract_source`, `source_attempts`, and `error_code` so agents can distinguish
 missing abstracts, source failures, DOI mismatches, and ambiguous evidence.
 
+Use `check-file` when a draft, literature note, or AI-agent output has many
+DOI/claim pairs.
+
+JSONL:
+
+```bash
+ref-verify check-file claims.jsonl
+ref-verify check-file claims.jsonl --json
+```
+
+CSV:
+
+```bash
+ref-verify check-file claims.csv
+```
+
+Each row must include `doi` and `claim`. Optional fields are `id`, `source`,
+and `note`. Batch mode reuses the same conservative `check-claim` engine:
+`ACCEPT` means the abstract explicitly supports the numeric claim. `WARN`,
+`PARTIAL`, `REJECT`, or `UNVERIFIABLE` means the claim should not be treated as
+verified.
+
 Current `check-claim` error codes:
 
 - `CLAIM_SUPPORTED`: explicit abstract support found.
@@ -205,7 +268,7 @@ Current `check-claim` error codes:
 - `NO_ABSTRACT`: attempted DOI-bound sources did not provide abstract text.
 - `DOI_NOT_FOUND`: selected source did not find a DOI-bound record.
 - `DOI_MISMATCH`: the primary or explicitly selected DOI-bound record did not match the requested DOI.
-- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_UNSUPPORTED`: source lookup failed or could not be used.
+- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
 
 > Core rule: every content statement about a paper must come from a live-fetched
 > abstract. If the abstract is inaccessible after fallback checks, say

{ref_verify-1.1.2 → ref_verify-1.2.0}/README.md

@@ -34,6 +34,8 @@ Works with **Claude Code, Cursor, Codex**, and any agent that supports the
 
 After installation, use it like a normal agent skill. You do not start a server and you do not configure MCP for this workflow. No MCP server is required for this workflow.
 
+For explicit agent tool-calling rules, see [AGENT_USAGE.md](https://github.com/Moonweave-Research/ref-verify/blob/main/AGENT_USAGE.md).
+
 ---
 
 ## Use it
@@ -64,10 +66,11 @@ checks that are currently safe to automate directly:
 
 - CrossRef metadata check: `ref-verify verify-doi`
 - DOI-bound abstract claim check: `ref-verify check-claim`
+- Batch DOI-bound claim checks: `ref-verify check-file`
   - literal text claims
   - subject-matched percentage claims such as efficiency, response rate, or actuation strain
   - simple unit/count claims such as cycles, patients, voltage, temperature, and concentration
-  - CrossRef first, then DOI-bound Semantic Scholar and PubMed fallback when CrossRef has no abstract
+  - CrossRef first, then DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback when CrossRef has no abstract
 - JSON output for agent-readable routing
 - Non-zero exit codes for `WARN`, `REJECT`, and `UNVERIFIABLE` results
 
@@ -75,7 +78,7 @@ Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ra
 
 The CLI has zero third-party Python runtime dependencies, but it is not an
 offline verifier. Functional checks require outbound HTTPS access to public
-academic APIs such as CrossRef, Semantic Scholar, and PubMed.
+academic APIs such as CrossRef, OpenAlex, Semantic Scholar, and PubMed.
 
 Install the CLI from a local checkout:
 
@@ -116,7 +119,7 @@ ref-verify check-claim 10.1126/science.287.5454.836 \
   --json
 ```
 
-By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound Semantic Scholar and PubMed fallback sources. Use `--source crossref`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
+By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback sources. Use `--source crossref`, `--source openalex`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
 
 Source-checkout equivalents:
 
@@ -158,6 +161,44 @@ normal CI does not fail because an upstream API is temporarily unavailable.
 
 ---
 
+## Scope — what it does and does not verify
+
+`ref-verify` is a conservative guard, not an oracle. It errs toward flagging: an
+`ACCEPT` is high-confidence, and **anything else means "not auto-verifiable —
+check it yourself", not "the citation is wrong."**
+
+**It verifies**
+
+- DOI metadata: title, first-author surname, and year against CrossRef.
+- Whether a DOI-bound **abstract** explicitly supports a specific numeric or
+  literal claim, quoted verbatim. If no abstract is reachable, it returns
+  `UNVERIFIABLE` rather than guessing.
+
+**It does not verify** (out of scope by design, not bugs)
+
+- **Full-text, figure, table, or supplementary values** — abstract-only. A number
+  that appears only in the body stays `UNVERIFIABLE`.
+- **Relational or qualitative claims** — proportionalities, mechanisms,
+  "broader/stronger than". Only value+unit and literal claims are checked.
+- **Papers whose publisher withholds the abstract** — some titles expose no
+  abstract to CrossRef or OpenAlex. No abstract → `UNVERIFIABLE`, which reflects
+  reachability, not the claim.
+- **Statistical metrics** (p-value, AUC/AUROC, F1, hazard/odds ratio, confidence
+  intervals) — handled by the manual skill protocol, not the CLI.
+- **Paper quality, novelty, field consensus**, or whether the *full* paper
+  supports a broader statement.
+
+**Reading a verdict**
+
+| Verdict | Meaning |
+|---|---|
+| `ACCEPT` | The fetched abstract explicitly supports the claim. High-confidence pass. |
+| `WARN` / `PARTIAL` | An abstract was read but does not explicitly support the exact claim. Check the source. |
+| `UNVERIFIABLE` | No abstract was reachable to check against. Not a judgment on the claim. |
+| `REJECT` | DOI is dead, resolves to a different paper, contradicted, or retracted. |
+
+---
+
 ## Modes
 
 **Quick Screen** is for DOIs you already have. It uses CrossRef to compare the
@@ -171,8 +212,8 @@ ref-verify verify-doi <doi> --title "<title>" --first-author <last-name> --year
 exit code, so weak or mismatched metadata cannot silently pass automation gates.
 
 **Full Audit** is for literature search and final pre-submission review. The
-skill fetches abstracts through CrossRef, Semantic Scholar, Unpaywall, arXiv,
-and PubMed where needed, then checks whether the paper supports the specific
+skill fetches abstracts through CrossRef, OpenAlex, Semantic Scholar, Unpaywall,
+arXiv, and PubMed where needed, then checks whether the paper supports the specific
 claim being cited.
 
 For a single DOI-backed claim, the CLI can run the abstract check:
@@ -186,6 +227,28 @@ ref-verify check-claim <doi> --claim "<specific claim>" --json
 `abstract_source`, `source_attempts`, and `error_code` so agents can distinguish
 missing abstracts, source failures, DOI mismatches, and ambiguous evidence.
 
+Use `check-file` when a draft, literature note, or AI-agent output has many
+DOI/claim pairs.
+
+JSONL:
+
+```bash
+ref-verify check-file claims.jsonl
+ref-verify check-file claims.jsonl --json
+```
+
+CSV:
+
+```bash
+ref-verify check-file claims.csv
+```
+
+Each row must include `doi` and `claim`. Optional fields are `id`, `source`,
+and `note`. Batch mode reuses the same conservative `check-claim` engine:
+`ACCEPT` means the abstract explicitly supports the numeric claim. `WARN`,
+`PARTIAL`, `REJECT`, or `UNVERIFIABLE` means the claim should not be treated as
+verified.
+
 Current `check-claim` error codes:
 
 - `CLAIM_SUPPORTED`: explicit abstract support found.
@@ -194,7 +257,7 @@ Current `check-claim` error codes:
 - `NO_ABSTRACT`: attempted DOI-bound sources did not provide abstract text.
 - `DOI_NOT_FOUND`: selected source did not find a DOI-bound record.
 - `DOI_MISMATCH`: the primary or explicitly selected DOI-bound record did not match the requested DOI.
-- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_UNSUPPORTED`: source lookup failed or could not be used.
+- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
 
 > Core rule: every content statement about a paper must come from a live-fetched
 > abstract. If the abstract is inaccessible after fallback checks, say

{ref_verify-1.1.2 → ref_verify-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ref-verify"
-version = "1.1.2"
+version = "1.2.0"
 description = "Executable DOI and claim verification helpers for academic citations"
 readme = "README.md"
 requires-python = ">=3.10"

{ref_verify-1.1.2 → ref_verify-1.2.0}/src/ref_verify/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.1.2"
+__version__ = "1.2.0"

{ref_verify-1.1.2 → ref_verify-1.2.0}/src/ref_verify/abstract_lookup.py

@@ -202,6 +202,8 @@ def _final_error_code(
         return "SOURCE_API_ERROR"
     if "TIMEOUT" in statuses:
         return "SOURCE_TIMEOUT"
+    if "RATE_LIMITED" in statuses:
+        return "SOURCE_RATE_LIMITED"
     if "UNSUPPORTED" in statuses and "NO_ABSTRACT" not in statuses:
         return "SOURCE_UNSUPPORTED"
     if statuses and all(status == "NOT_FOUND" for status in statuses):

ref_verify-1.2.0/src/ref_verify/batch.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import csv
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+BatchFormat = Literal["jsonl", "csv"]
+_VALID_SOURCES = {"auto", "crossref", "openalex", "semantic-scholar", "pubmed"}
+_FAILED_ERROR_CODES = {
+    "ROW_CHECK_ERROR",
+    "SOURCE_API_ERROR",
+    "SOURCE_TIMEOUT",
+    "SOURCE_RATE_LIMITED",
+    "SOURCE_UNSUPPORTED",
+}
+
+
+class BatchInputError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class ClaimInputRow:
+    row_number: int
+    id: str | None
+    doi: str
+    claim: str
+    source: str = "auto"
+    note: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class BatchRowResult:
+    row: ClaimInputRow
+    payload: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        result = {
+            "row_number": self.row.row_number,
+            "id": self.row.id,
+            "doi": self.row.doi,
+            "claim": self.row.claim,
+        }
+        if self.row.note is not None:
+            result["note"] = self.row.note
+        result.update(self.payload)
+        return result
+
+
+@dataclass(frozen=True)
+class BatchSummary:
+    total: int
+    accept: int
+    warn: int
+    reject: int
+    partial: int
+    unverifiable: int
+    failed: int
+
+    def to_dict(self) -> dict[str, int]:
+        return asdict(self)
+
+
+def detect_format(path: Path, explicit_format: str | None) -> BatchFormat:
+    if explicit_format in ("jsonl", "csv"):
+        return explicit_format
+    if explicit_format is not None:
+        raise BatchInputError(f"Unsupported input format: {explicit_format}")
+    suffix = path.suffix.lower()
+    if suffix == ".jsonl":
+        return "jsonl"
+    if suffix == ".csv":
+        return "csv"
+    raise BatchInputError("Unsupported input format; use .jsonl, .csv, or --format")
+
+
+def parse_claim_file(path: Path, explicit_format: str | None) -> list[ClaimInputRow]:
+    batch_format = detect_format(path, explicit_format)
+    try:
+        if batch_format == "jsonl":
+            rows = _parse_jsonl(path)
+        else:
+            rows = _parse_csv(path)
+    except OSError as exc:
+        raise BatchInputError(f"Could not read input file: {exc}") from exc
+    if not rows:
+        raise BatchInputError("Input file does not contain any claim rows")
+    return rows
+
+
+def summarize_results(results: list[BatchRowResult]) -> BatchSummary:
+    accept = warn = reject = partial = unverifiable = failed = 0
+    for result in results:
+        verdict = str(result.payload.get("verdict", ""))
+        status = str(result.payload.get("status", ""))
+        if verdict == "ACCEPT":
+            accept += 1
+        if verdict == "WARN":
+            warn += 1
+        if verdict == "REJECT":
+            reject += 1
+        if status == "PARTIAL":
+            partial += 1
+        if status == "UNVERIFIABLE":
+            unverifiable += 1
+        if verdict == "ERROR" or str(result.payload.get("error_code", "")) in _FAILED_ERROR_CODES:
+            failed += 1
+    return BatchSummary(
+        total=len(results),
+        accept=accept,
+        warn=warn,
+        reject=reject,
+        partial=partial,
+        unverifiable=unverifiable,
+        failed=failed,
+    )
+
+
+def batch_payload(results: list[BatchRowResult]) -> dict[str, Any]:
+    return {
+        "summary": summarize_results(results).to_dict(),
+        "results": [result.to_dict() for result in results],
+    }
+
+
+def render_batch_text(results: list[BatchRowResult]) -> str:
+    summary = summarize_results(results)
+    lines = [
+        (
+            f"Summary: total={summary.total} accept={summary.accept} "
+            f"warn={summary.warn} reject={summary.reject} "
+            f"partial={summary.partial} unverifiable={summary.unverifiable} "
+            f"failed={summary.failed}"
+        )
+    ]
+    for result in results:
+        payload = result.payload
+        label = str(payload.get("verdict", "WARN"))
+        row_id = result.row.id or f"row-{result.row.row_number}"
+        lines.extend(
+            [
+                "",
+                f"{label}  {row_id}  {result.row.doi}",
+                f"Claim: {result.row.claim}",
+                f"Reason: {payload.get('reason', '')}",
+            ]
+        )
+        evidence = payload.get("evidence")
+        if evidence:
+            lines.append(f"Evidence: {evidence}")
+        error_code = payload.get("error_code")
+        if error_code:
+            lines.append(f"Error code: {error_code}")
+    return "\n".join(lines)
+
+
+def _parse_jsonl(path: Path) -> list[ClaimInputRow]:
+    rows: list[ClaimInputRow] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            stripped = line.strip()
+            if not stripped:
+                continue
+            try:
+                raw = json.loads(stripped)
+            except json.JSONDecodeError as exc:
+                raise BatchInputError(f"Invalid JSON on line {line_number}: {exc.msg}") from exc
+            if not isinstance(raw, dict):
+                raise BatchInputError(f"Invalid row on line {line_number}: expected object")
+            rows.append(_row_from_mapping(raw, line_number=line_number, row_label="line"))
+    return rows
+
+
+def _parse_csv(path: Path) -> list[ClaimInputRow]:
+    rows: list[ClaimInputRow] = []
+    with path.open("r", encoding="utf-8-sig", newline="") as handle:
+        reader = csv.DictReader(handle, skipinitialspace=True)
+        if reader.fieldnames is None:
+            raise BatchInputError("CSV input is missing a header row")
+        fieldnames = {_normalize_csv_fieldname(field) for field in reader.fieldnames if field}
+        missing = {"doi", "claim"} - fieldnames
+        if missing:
+            missing_fields = ", ".join(sorted(missing))
+            raise BatchInputError(f"CSV header must include doi and claim fields; missing: {missing_fields}")
+        for row_number, raw in enumerate(reader, start=2):
+            rows.append(
+                _row_from_mapping(
+                    _normalize_csv_row(raw),
+                    line_number=row_number,
+                    row_label="line",
+                )
+            )
+    return rows
+
+
+def _row_from_mapping(raw: dict[str, Any], *, line_number: int, row_label: str) -> ClaimInputRow:
+    doi = _required_string(raw, "doi", line_number, row_label)
+    claim = _required_string(raw, "claim", line_number, row_label)
+    source = _optional_string(raw, "source") or "auto"
+    if source not in _VALID_SOURCES:
+        raise BatchInputError(f"Invalid field on {row_label} {line_number}: source={source}")
+    return ClaimInputRow(
+        row_number=line_number,
+        id=_optional_string(raw, "id"),
+        doi=doi,
+        claim=claim,
+        source=source,
+        note=_optional_string(raw, "note"),
+    )
+
+
+def _required_string(raw: dict[str, Any], field: str, line_number: int, row_label: str) -> str:
+    value = raw.get(field)
+    if not isinstance(value, str) or not value.strip():
+        raise BatchInputError(f"Missing required field on {row_label} {line_number}: {field}")
+    return value.strip()
+
+
+def _optional_string(raw: dict[str, Any], field: str) -> str | None:
+    value = raw.get(field)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        return str(value)
+    stripped = value.strip()
+    return stripped or None
+
+
+def _normalize_csv_fieldname(field: str) -> str:
+    return field.lstrip("\ufeff").strip()
+
+
+def _normalize_csv_row(raw: dict[str, Any]) -> dict[str, Any]:
+    return {_normalize_csv_fieldname(key): value for key, value in raw.items() if key is not None}

{ref_verify-1.1.2 → ref_verify-1.2.0}/src/ref_verify/claim_check.py

@@ -209,7 +209,7 @@ _UNSUPPORTED_CLAIM_FRAME_PATTERNS = (
     r"\bsaid to\b",
     r"\b(?:expect|expects|expected|expecting) to\b",
     r"\b(?:project|projects|projected|projecting) to\b",
-    r"\b(?:estimate|estimates|estimated|estimating) to\b",
+    r"\b(?:estimate|estimates|estimated|estimating) to (?!be\b|equal\b|at\b|about\b)",
     r"\bachievable\b",
     r"\bpossible\b",
 )
@@ -338,6 +338,8 @@ def _claim_percentage_comparator(claim: str) -> str:
         return "gte"
     if re.search(r"\b(at most|no more than)\b", normalized):
         return "lte"
+    if re.search(r"\bup to\b", normalized):
+        return "up_to"
     if re.search(r"\b(below|under|less than)\b", normalized):
         return "lt"
     if re.search(
@@ -414,6 +416,8 @@ def _evidence_entails_claim(
     claim_comparator: str,
 ) -> bool:
     if evidence_comparator == "up_to":
+        if claim_comparator == "up_to":
+            return value == threshold
         if claim_comparator == "exact":
             return False
         return _compare_percentage(value, threshold, claim_comparator)