claimproofkit 0.1.0__py3-none-any.whl

claimproofkit/cli.py

@@ -0,0 +1,136 @@
+# Copyright 2026 Daniel Kissel
+# SPDX-License-Identifier: Apache-2.0
+
+"""``claimproofkit`` CLI — mirrors the Swift executable's commands and exit codes.
+
+Exit codes: 0 published / gate passed, 2 blocked, 3 benchmark gate failed,
+64 usage, 65 unreadable input, 73 provenance trace write failed.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+from typing import List, Optional
+
+from .benchmark import BenchmarkCorpus, BenchmarkRunner
+from .models import EvidencePassage, SourceType, VerificationPolicy
+from .provenance import ProvenanceExporter
+from .report import benchmark_report_json, render_benchmark_markdown, render_report_markdown
+from .verifier import ClaimVerifier
+
+USAGE = """Usage:
+  claimproofkit verify <input.json> [--provenance <trace.json>]
+  claimproofkit benchmark <corpus.json> [--json]
+
+--provenance writes a DProvenanceKit-compatible trace manifest of the
+verification run alongside the report.
+
+Exit codes: 0 published, 2 blocked, 3 benchmark gate failed,
+64 usage, 65 unreadable input, 73 provenance trace write failed.
+
+Backward compatibility: claimproofkit <input.json> runs verification.
+"""
+
+
+def _usage(code: int) -> int:
+    sys.stderr.write(USAGE)
+    return code
+
+
+def _run_verification(path: str, provenance_path: Optional[str]) -> int:
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+        evidence = [
+            EvidencePassage(
+                id=p["id"],
+                source=p["source"],
+                source_type=SourceType(p["sourceType"]),
+                text=p["text"],
+            )
+            for p in data["evidence"]
+        ]
+        policy = VerificationPolicy()
+        report = ClaimVerifier(policy).verify_document(data["document"], evidence, created_at=time.time())
+    except Exception as error:  # noqa: BLE001 - CLI boundary
+        sys.stderr.write(f"claimproofkit: {error}\n")
+        return 65
+
+    # The report is always emitted, even if the trace write fails afterwards.
+    print(render_report_markdown(report))
+    if provenance_path is not None:
+        try:
+            trace = ProvenanceExporter().trace(report, policy)
+            with open(provenance_path, "w", encoding="utf-8") as handle:
+                handle.write(trace.manifest_json())
+            sys.stderr.write(
+                f"provenance trace written to {provenance_path} (run fingerprint {trace.run_fingerprint})\n"
+            )
+        except Exception as error:  # noqa: BLE001 - CLI boundary
+            sys.stderr.write(f"claimproofkit: failed to write provenance trace to {provenance_path}: {error}\n")
+            return 73
+    return 0 if report.is_safe_to_publish else 2
+
+
+def _run_benchmark(path: str, as_json: bool) -> int:
+    try:
+        with open(path, encoding="utf-8") as handle:
+            corpus = BenchmarkCorpus.from_dict(json.load(handle))
+    except Exception as error:  # noqa: BLE001 - CLI boundary
+        sys.stderr.write(f"claimproofkit: {error}\n")
+        return 65
+    report = BenchmarkRunner().run(corpus)
+    print(benchmark_report_json(report) if as_json else render_benchmark_markdown(report))
+    return 0 if report.passes_safety_gate else 3
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    # The Swift CLI writes UTF-8 bytes unconditionally; without this, a
+    # non-UTF-8 stdout (e.g. cp1252) crashes mid-print with exit 1 and breaks
+    # the documented exit-code contract.
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is not None:
+            reconfigure(encoding="utf-8", errors="backslashreplace")
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    if "--help" in arguments or "-h" in arguments:
+        sys.stderr.write(USAGE)
+        return 0
+    if not arguments:
+        return _usage(64)
+
+    command = arguments[0]
+    if command == "verify":
+        path: Optional[str] = None
+        provenance: Optional[str] = None
+        rest = arguments[1:]
+        while rest:
+            argument = rest.pop(0)
+            if argument == "--provenance":
+                if provenance is not None or not rest:
+                    return _usage(64)
+                provenance = rest.pop(0)
+            elif path is None:
+                path = argument
+            else:
+                return _usage(64)
+        if path is None:
+            return _usage(64)
+        return _run_verification(path, provenance)
+    if command == "benchmark":
+        rest = arguments[1:]
+        if len(rest) == 1:
+            return _run_benchmark(rest[0], as_json=False)
+        if len(rest) == 2 and rest[1] == "--json":
+            return _run_benchmark(rest[0], as_json=True)
+        return _usage(64)
+    if len(arguments) == 1:
+        # Backward compatibility: a lone path runs verification.
+        return _run_verification(command, None)
+    return _usage(64)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

claimproofkit/extractor.py

@@ -0,0 +1,113 @@
+# Copyright 2026 Daniel Kissel
+# SPDX-License-Identifier: Apache-2.0
+
+"""Claim extraction — mirrors the Swift `ClaimExtractor.swift`.
+
+Claim ids and ranges use UTF-16 code-unit offsets (Swift extracts with
+NSRegularExpression over NSString), so ids like ``claim-46-0`` are identical
+across both implementations even for documents containing astral-plane
+characters.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List
+
+from ._text import split_words, swift_lower, swift_trim_whitespace
+from .models import Claim, ClaimType
+
+# ICU's non-multiline `$` (NSRegularExpression) matches at end of string AND
+# before a final line terminator; Python's non-MULTILINE `$` matches at end
+# and before a final "\n". Combined with the `[^.!?\n]+` class and the
+# Swift-parity trimming below, the extracted claim text and fingerprint are
+# identical for every terminator (\n, \r\n, U+0085, U+2028, U+2029) —
+# verified differentially against the Swift CLI.
+_SENTENCE = re.compile(r"[^.!?\n]+(?:[.!?]+|$)")
+
+# ICU regex `\s` does NOT include the information separators U+001C-U+001F;
+# Python's Unicode `\s` does, so the whitespace class is spelled out to match
+# ICU's set exactly.
+_ICU_WS = "\\t-\\r \\x85\\xa0\\u1680\\u2000-\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000"
+_CLAUSE_SEPARATOR = re.compile(f"[{_ICU_WS}]+(?:and|but)[{_ICU_WS}]+", re.IGNORECASE)
+
+_NON_CLAIMS = ("please note", "this document is not legal advice")
+
+
+def _utf16_offset(document: str, char_index: int) -> int:
+    """Number of UTF-16 code units before ``char_index`` (Swift NSRange origin)."""
+    prefix = document[:char_index]
+    return sum(2 if ord(ch) > 0xFFFF else 1 for ch in prefix)
+
+
+def _utf16_length(text: str) -> int:
+    return sum(2 if ord(ch) > 0xFFFF else 1 for ch in text)
+
+
+def _is_material_claim(text: str) -> bool:
+    if not text or text.endswith("?"):
+        return False
+    if len(split_words(text)) < 4:
+        return False
+    lower = swift_lower(text)
+    return not any(marker in lower for marker in _NON_CLAIMS)
+
+
+def _atomic_clauses(sentence: str) -> List[str]:
+    # Swift replaces separator matches with a U+001F sentinel and then splits
+    # on it, so a pre-existing U+001F in the sentence also acts as a clause
+    # boundary. Reproduce that exactly rather than using re.split.
+    sentinel = _CLAUSE_SEPARATOR.sub("\x1f", sentence)
+    parts = [swift_trim_whitespace(part) for part in sentinel.split("\x1f")]
+    parts = [p for p in parts if p]
+    # Swift's split(separator: " ") drops empty subsequences, so runs of spaces
+    # must not inflate the word count here.
+    if len(parts) > 1 and all(len([w for w in p.split(" ") if w]) >= 3 for p in parts):
+        return parts
+    return [sentence]
+
+
+def _classify(claim: str) -> ClaimType:
+    lower = swift_lower(claim)
+    if " recommends " in lower or lower.startswith("recommend "):
+        return ClaimType.RECOMMENDATION
+    if " therefore " in lower or " violated " in lower:
+        return ClaimType.LEGAL_CONCLUSION
+    if (
+        " law requires " in lower
+        or " statute " in lower
+        or " rule requires " in lower
+        or " must be filed" in lower
+        or " shall be filed" in lower
+    ):
+        return ClaimType.LEGAL_RULE
+    if " calculated " in lower or " equals " in lower:
+        return ClaimType.CALCULATION
+    if '"' in claim:
+        return ClaimType.QUOTATION
+    return ClaimType.FACTUAL
+
+
+class ClaimExtractor:
+    """Deterministic sentence/clause extractor, spec-locked with the Swift one."""
+
+    def extract(self, document: str) -> List[Claim]:
+        claims: List[Claim] = []
+        for match in _SENTENCE.finditer(document):
+            raw = match.group(0)
+            text = swift_trim_whitespace(raw)
+            if not _is_material_claim(text):
+                continue
+            start = _utf16_offset(document, match.start())
+            length = _utf16_length(raw)
+            for index, clause in enumerate(_atomic_clauses(text)):
+                claims.append(
+                    Claim(
+                        id=f"claim-{start}-{index}",
+                        text=clause,
+                        type=_classify(clause),
+                        parent_text=None if clause == text else text,
+                        range=(start, start + length),
+                    )
+                )
+        return claims

claimproofkit/identity.py

@@ -0,0 +1,134 @@
+# Copyright 2026 Daniel Kissel
+# SPDX-License-Identifier: Apache-2.0
+
+"""Claim Proof Specification v1 identity algorithms.
+
+Mirrors the Swift `ProofIdentity.swift` byte-for-byte. Every function here is
+locked by the golden vectors vendored under ``conformance/vectors`` (whose
+source of truth is the Swift repo's ConformanceHarness).
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from typing import Any
+
+from .models import EvidencePassage, ProofReport, VerificationPolicy
+
+SPEC_VERSION = "1.0"
+VERIFIER_IDENTIFIER = "cpk-lexical"
+VERIFIER_VERSION = "1.0"
+
+
+def sha256_hex(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def swift_number(value: Any) -> str:
+    """Render a number the way Swift's ``JSONEncoder`` does.
+
+    Integral Doubles print without a fractional part (``Double(1)`` → ``"1"``)
+    up to the magnitude where Swift switches to exponent form (1e16); above
+    that, and for all non-integral values, Swift uses shortest round-trip
+    rendering, which matches Python's ``repr`` for finite floats. Negative
+    zero stays ``"-0"``.
+    """
+    if isinstance(value, bool):  # bool is an int subclass; keep JSON booleans out
+        raise TypeError("swift_number does not take booleans")
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError("non-finite numbers are not canonically encodable")
+        if value == 0 and math.copysign(1, value) < 0:
+            return "-0"
+        if value.is_integer() and abs(value) < 1e16:
+            return str(int(value))
+        return repr(value)
+    raise TypeError(f"not a number: {value!r}")
+
+
+def swift_interpolation(value: Any) -> str:
+    """Render a number the way Swift STRING INTERPOLATION does — distinct from
+    JSON encoding: ``"\\(Double(1))"`` is ``"1.0"``, not ``"1"``. Python's
+    ``repr`` for floats matches Swift's Double description exactly for the
+    shortest-round-trip cases used in fingerprint listings.
+    """
+    if isinstance(value, bool):
+        raise TypeError("swift_interpolation does not take booleans")
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if not math.isfinite(value):
+            raise ValueError("non-finite numbers are not interpolatable")
+        return repr(value)
+    raise TypeError(f"not a number: {value!r}")
+
+
+def _json_string(text: str) -> str:
+    # Swift's JSONEncoder escapes forward slashes by default (the bridge encodes
+    # rawJSON with plain .sortedKeys), so the canonical form does too.
+    return json.dumps(text, ensure_ascii=False).replace("/", "\\/")
+
+
+def _canonical_fragment(value: Any) -> str:
+    if isinstance(value, str):
+        return _json_string(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, (int, float)):
+        return swift_number(value)
+    if isinstance(value, dict):
+        items = sorted(value.items(), key=lambda kv: kv[0])
+        inner = ",".join(f"{_json_string(k)}:{_canonical_fragment(v)}" for k, v in items)
+        return "{" + inner + "}"
+    if isinstance(value, (list, tuple)):
+        return "[" + ",".join(_canonical_fragment(v) for v in value) + "]"
+    if value is None:
+        return "null"
+    raise TypeError(f"not canonically encodable: {type(value).__name__}")
+
+
+def canonical_json(value: Any) -> str:
+    """Canonical payload encoding (Spec §2): sorted keys, UTF-8, no extra
+    whitespace, Swift number rendering. Byte-identical to Swift's
+    ``JSONEncoder`` with ``.sortedKeys`` for the payload types used on the wire.
+    """
+    return _canonical_fragment(value)
+
+
+def evidence_content_fingerprint(passage: EvidencePassage) -> str:
+    """Spec §5: SHA-256 over the exact UTF-8 bytes of the passage text."""
+    return sha256_hex(passage.text)
+
+
+def report_fingerprint(report: ProofReport) -> str:
+    """Spec §3: SHA-256 over the domain-separated verdict signature string."""
+    signature = "".join(f"{v.claim.fingerprint}:{v.status.value}|" for v in report.verdicts)
+    return sha256_hex("cpk:v1:report:" + signature)
+
+
+def policy_fingerprint(
+    policy: VerificationPolicy,
+    verifier: str = VERIFIER_IDENTIFIER,
+    verifier_version: str = VERIFIER_VERSION,
+) -> str:
+    """Spec §4: SHA-256 over the frozen newline-delimited key:value listing.
+
+    The Swift reference builds this listing with STRING INTERPOLATION (not
+    JSONEncoder), so integral thresholds render as ``1.0``, never ``1``.
+    """
+    canonical = "\n".join(
+        [
+            f"specVersion:{SPEC_VERSION}",
+            f"verifier:{verifier}",
+            f"verifierVersion:{verifier_version}",
+            f"supportedThreshold:{swift_interpolation(float(policy.supported_threshold))}",
+            f"ambiguousThreshold:{swift_interpolation(float(policy.ambiguous_threshold))}",
+            f"contradictionThreshold:{swift_interpolation(float(policy.contradiction_threshold))}",
+            f"maximumEvidenceMatches:{policy.maximum_evidence_matches}",
+        ]
+    )
+    return sha256_hex(canonical)

claimproofkit/models.py

@@ -0,0 +1,133 @@
+# Copyright 2026 Daniel Kissel
+# SPDX-License-Identifier: Apache-2.0
+
+"""Core data model — mirrors the Swift ClaimProofKit `Models.swift` exactly.
+
+Claim Proof Specification v1 locks the claim fingerprint algorithm here; the
+rest of the identity surface lives in :mod:`claimproofkit.identity`.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional, Tuple
+
+
+class SourceType(str, Enum):
+    EVIDENCE = "evidence"
+    DECLARATION = "declaration"
+    COURT_RECORD = "courtRecord"
+    STATUTE = "statute"
+    REGULATION = "regulation"
+    COURT_RULE = "courtRule"
+    CASE_LAW = "caseLaw"
+    CALCULATION_INPUT = "calculationInput"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class EvidencePassage:
+    id: str
+    source: str
+    text: str
+    source_type: SourceType = SourceType.UNKNOWN
+
+
+class ClaimType(str, Enum):
+    FACTUAL = "factual"
+    LEGAL_RULE = "legalRule"
+    LEGAL_CONCLUSION = "legalConclusion"
+    CALCULATION = "calculation"
+    RECOMMENDATION = "recommendation"
+    QUOTATION = "quotation"
+    UNKNOWN = "unknown"
+
+
+def make_claim_fingerprint(text: str) -> str:
+    """FNV-1a 64-bit over the lowercased UTF-8 claim text, unpadded lowercase hex.
+
+    Spec §1. Byte-for-byte identical to Swift's ``Claim.makeFingerprint``:
+    offset basis 14695981039346656037, prime 1099511628211, XOR-then-wrapping-
+    multiply per byte, rendered via ``String(hash, radix: 16)`` (no zero padding).
+    Lowercasing uses ``swift_lower`` (no Final_Sigma rule) and hashes the
+    original scalars — no Unicode normalization, matching Swift exactly.
+    """
+    from ._text import swift_lower
+
+    fnv = 14_695_981_039_346_656_037
+    for byte in swift_lower(text).encode("utf-8"):
+        fnv ^= byte
+        fnv = (fnv * 1_099_511_628_211) & 0xFFFF_FFFF_FFFF_FFFF
+    return format(fnv, "x")
+
+
+@dataclass(frozen=True)
+class Claim:
+    id: str
+    text: str
+    type: ClaimType = ClaimType.UNKNOWN
+    parent_text: Optional[str] = None
+    fingerprint: str = ""
+    range: Optional[Tuple[int, int]] = None  # UTF-16 code-unit offsets, like Swift
+
+    def __post_init__(self) -> None:
+        if not self.fingerprint:
+            object.__setattr__(self, "fingerprint", make_claim_fingerprint(self.text))
+
+
+class SupportStatus(str, Enum):
+    DIRECTLY_SUPPORTED = "directlySupported"
+    SUPPORTED_BY_INFERENCE = "supportedByInference"
+    PARTIALLY_SUPPORTED = "partiallySupported"
+    CONTRADICTED = "contradicted"
+    AMBIGUOUS = "ambiguous"
+    UNSUPPORTED = "unsupported"
+    NOT_VERIFIABLE = "notVerifiable"
+
+
+APPROVED_STATUSES = frozenset(
+    {SupportStatus.DIRECTLY_SUPPORTED, SupportStatus.SUPPORTED_BY_INFERENCE}
+)
+
+
+@dataclass(frozen=True)
+class EvidenceMatch:
+    passage: EvidencePassage
+    score: float
+    matched_terms: Tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class ClaimVerdict:
+    claim: Claim
+    status: SupportStatus
+    confidence: float
+    evidence: Tuple[EvidenceMatch, ...]
+    explanation: str
+
+
+@dataclass(frozen=True)
+class ProofReport:
+    verdicts: Tuple[ClaimVerdict, ...]
+    version: int = 1
+    created_at: float = 0.0  # POSIX seconds; explicit, never implicit "now"
+
+    @property
+    def is_safe_to_publish(self) -> bool:
+        return bool(self.verdicts) and all(v.status in APPROVED_STATUSES for v in self.verdicts)
+
+    @property
+    def support_rate(self) -> float:
+        if not self.verdicts:
+            return 0.0
+        supported = sum(1 for v in self.verdicts if v.status in APPROVED_STATUSES)
+        return supported / len(self.verdicts)
+
+
+@dataclass(frozen=True)
+class VerificationPolicy:
+    supported_threshold: float = 0.80
+    ambiguous_threshold: float = 0.40
+    contradiction_threshold: float = 0.55
+    maximum_evidence_matches: int = 3

claimproofkit/pipeline.py

@@ -0,0 +1,145 @@
+# Copyright 2026 Daniel Kissel
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pluggable verification pipeline — mirrors the Swift `VerificationProtocols.swift`
+and `VerificationPipeline.swift` contracts so local or external verifiers
+(semantic entailment, retrieval, human review) can be substituted without
+changing the report contract. Swift's async protocol methods map to plain
+Python methods; substitute async implementations by overriding `verify_document`.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Sequence, Tuple
+
+from .extractor import ClaimExtractor
+from .models import Claim, ClaimVerdict, EvidencePassage, ProofReport, SupportStatus
+from .verifier import ClaimVerifier
+
+
+class AtomicClaimExtracting(ABC):
+    @abstractmethod
+    def extract(self, document: str) -> List[Claim]: ...
+
+
+class EvidenceRetrieving(ABC):
+    @abstractmethod
+    def retrieve(
+        self, claim: Claim, corpus: Sequence[EvidencePassage], limit: int
+    ) -> List[EvidencePassage]: ...
+
+
+class ClaimEntailmentVerifying(ABC):
+    @abstractmethod
+    def verify(self, claim: Claim, evidence: Sequence[EvidencePassage]) -> ClaimVerdict: ...
+
+
+class ProofPolicyEvaluating(ABC):
+    @abstractmethod
+    def evaluate(self, report: ProofReport) -> "ProofDecision": ...
+
+
+class TrustReportGenerating(ABC):
+    @abstractmethod
+    def generate(self, verdicts: Sequence[ClaimVerdict]) -> ProofReport: ...
+
+
+class Disposition(str, Enum):
+    ALLOW = "allow"
+    REQUIRE_REVIEW = "requireReview"
+    BLOCK = "block"
+
+
+@dataclass(frozen=True)
+class ProofDecision:
+    disposition: Disposition
+    blocking_claim_ids: Tuple[str, ...] = ()
+    review_claim_ids: Tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class PipelineResult:
+    report: ProofReport
+    decision: ProofDecision
+
+
+class PassthroughEvidenceRetriever(EvidenceRetrieving):
+    def retrieve(
+        self, claim: Claim, corpus: Sequence[EvidencePassage], limit: int
+    ) -> List[EvidencePassage]:
+        return list(corpus[: max(1, limit)])
+
+
+class LexicalEntailmentVerifier(ClaimEntailmentVerifying):
+    def __init__(self, verifier: "ClaimVerifier | None" = None):
+        self._verifier = verifier if verifier is not None else ClaimVerifier()
+
+    def verify(self, claim: Claim, evidence: Sequence[EvidencePassage]) -> ClaimVerdict:
+        return self._verifier.verify(claim, evidence)
+
+
+class DefaultTrustReportGenerator(TrustReportGenerating):
+    def generate(self, verdicts: Sequence[ClaimVerdict]) -> ProofReport:
+        return ProofReport(verdicts=tuple(verdicts))
+
+
+class ConservativeProofPolicy(ProofPolicyEvaluating):
+    def evaluate(self, report: ProofReport) -> ProofDecision:
+        blocking = tuple(
+            v.claim.id
+            for v in report.verdicts
+            if v.status in (SupportStatus.CONTRADICTED, SupportStatus.UNSUPPORTED)
+        )
+        review = tuple(
+            v.claim.id
+            for v in report.verdicts
+            if v.status
+            in (SupportStatus.PARTIALLY_SUPPORTED, SupportStatus.AMBIGUOUS, SupportStatus.NOT_VERIFIABLE)
+        )
+        if blocking:
+            return ProofDecision(
+                disposition=Disposition.BLOCK, blocking_claim_ids=blocking, review_claim_ids=review
+            )
+        if review:
+            return ProofDecision(disposition=Disposition.REQUIRE_REVIEW, review_claim_ids=review)
+        return ProofDecision(disposition=Disposition.ALLOW)
+
+
+class VerificationPipeline:
+    def __init__(
+        self,
+        extractor: "AtomicClaimExtracting | None" = None,
+        retriever: "EvidenceRetrieving | None" = None,
+        verifier: "ClaimEntailmentVerifying | None" = None,
+        policy: "ProofPolicyEvaluating | None" = None,
+        report_generator: "TrustReportGenerating | None" = None,
+        evidence_limit: int = 20,
+    ):
+        self._extractor = extractor if extractor is not None else _DefaultExtractor()
+        self._retriever = retriever if retriever is not None else PassthroughEvidenceRetriever()
+        self._verifier = verifier if verifier is not None else LexicalEntailmentVerifier()
+        self._policy = policy if policy is not None else ConservativeProofPolicy()
+        self._report_generator = (
+            report_generator if report_generator is not None else DefaultTrustReportGenerator()
+        )
+        self._evidence_limit = max(1, evidence_limit)
+
+    def verify_document(self, document: str, corpus: Sequence[EvidencePassage]) -> PipelineResult:
+        claims = self._extractor.extract(document)
+        verdicts = []
+        for claim in claims:
+            evidence = self._retriever.retrieve(claim, corpus, self._evidence_limit)
+            verdicts.append(self._verifier.verify(claim, evidence))
+        report = self._report_generator.generate(verdicts)
+        return PipelineResult(report=report, decision=self._policy.evaluate(report))
+
+
+class _DefaultExtractor(AtomicClaimExtracting):
+    def __init__(self) -> None:
+        self._extractor = ClaimExtractor()
+
+    def extract(self, document: str) -> List[Claim]:
+        return self._extractor.extract(document)