Why Does Ethos Use Source Fingerprints for Citation Verification?

Direct answer

Ethos uses source fingerprints to bind citations to exact document content. A filename, URL, or document title can remain unchanged after a source is replaced; a cryptographic fingerprint changes when the source bytes change. By comparing the citation’s expected fingerprint with the trusted grounding source fingerprint, Ethos can detect stale evidence before it is reused.

A matching fingerprint proves identity, not authority or semantic correctness. The application still decides whether that version is approved, effective, authorized, and relevant.

The outdated-document RAG guide explains the business risk. The Ethos citation-status guide explains how staleness affects verification.

Why names and URLs are weak identities

Consider these common events:

• policy.pdf is overwritten with a new revision;
• a cloud-storage URL redirects to a replacement file;
• two departments upload different files with the same name;
• an index retains old chunks after source replacement;
• a cache serves an answer created from a previous version;
• a parser artifact is rebuilt from changed bytes;
• a downloaded copy diverges from its canonical source.

The human label remains stable while the evidence changes. A fingerprint turns content identity into a machine-testable value.

Ethos fingerprint layers

Ethos distinguishes related identities.

Citation freshness primarily compares citation identity with the grounding source identity. The broader document fingerprint supports reproducible comparisons of parsed artifacts.

How the source fingerprint is computed

The determinism contract defines the source fingerprint as SHA-256 over the original PDF bytes, represented with a sha256: prefix and lowercase hexadecimal digest.

source.fingerprint = "sha256:" + sha256(source PDF bytes)

Even a one-byte change normally produces a different digest. This makes accidental or unauthorized source replacement visible.

The fingerprint is not encryption. It does not hide document content, and a digest of predictable content may still reveal membership. Treat fingerprints as security-relevant identifiers and apply tenant and access boundaries.

How fingerprint checking works during verification

citation envelope fingerprint
          |
          v
compare with GroundingSource fingerprint
          |
   match  |  mismatch / unavailable
          |
continue evidence checks   stale or capability-limited policy

When matching is required and values differ, Ethos marks report-level staleness. all_evidence_grounded cannot become true, and otherwise grounded checks are not reusable while the report is stale.

This fail-closed rule prevents an old citation from retaining proof status because its quoted words still happen to exist.

Why staleness is report-level

Suppose a citation set contains three quotes that all match a revised document, but the request fingerprint belongs to an earlier version. Treating the quotes as reusable would erase the fact that the submitted evidence request was prepared against another source state.

Report-level invalidation preserves the contract:

• the request as submitted is not certified;
• evidence may be regenerated against the new source;
• new verification can produce a new report;
• the old report remains an accurate audit artifact.

Silent repair should not mutate history.

Content identity versus authority

A fingerprint is powerful because it is narrow. Do not describe it as proof that a document is correct or authoritative.

Canonicalization and stable payloads

Ethos uses canonical JSON rules for stable values. The contract specifies UTF-8 encoding, sorted object keys, controlled string escaping, integer-only canonical numbers, preserved array order, and exclusions for runtime-dependent diagnostics.

Precise bounding boxes can remain emitted for inspection while being excluded from the fingerprint-critical stable payload projection when platform-sensitive rectangle differences would otherwise create false drift. Stable origin locators and other semantic evidence remain bound.

This separation avoids two bad outcomes:

1. ignoring meaningful content changes;
2. invalidating fingerprints because of non-semantic runtime noise.

Deterministic IDs and ordering

The fingerprint contract depends on stable structure. Ethos IDs use deterministic ordering rather than random or time-based values. Page, span, element, table, region, chunk, warning, finding, and check identifiers follow documented order rules.

Stable ordering matters because arrays are semantic in canonical JSON. If equivalent elements appear in a different order, the payload represents different reading or evidence structure and should not be casually treated as identical.

Fingerprints through the RAG pipeline

Carry fingerprint identity into:

• parsed document artifacts;
• chunks and embedding records;
• retrieval results;
• generated evidence references;
• citation requests;
• verification reports;
• answer caches;
• crop descriptors;
• audit records.

A cache key should include relevant source-set or index identity. Keying only by user question can return an answer created from stale documents.

Source-change workflow

When a source fingerprint changes:

1. Mark prior parsed artifacts as belonging to the old source.
2. Parse the new source under the approved profile.
3. rebuild affected chunks and index records.
4. Invalidate retrieval and answer caches.
5. Re-run critical question and citation fixtures.
6. Reverify citations intended for continued use.
7. Preserve old records according to audit and retention policy.
8. Update source authority and effective-date metadata.

Do not simply replace the old artifact in place while preserving its identity.

Multi-document source sets

A RAG answer can cite several documents. Applications may record individual source fingerprints and a deterministic source-set identity.

{
  "source_set_id": "policy-corpus-2026-07",
  "sources": [
    {"id": "benefits-policy", "fingerprint": "sha256:source-a"},
    {"id": "travel-policy", "fingerprint": "sha256:source-b"},
    {"id": "expense-procedure", "fingerprint": "sha256:source-c"}
  ]
}

Sort entries deterministically before hashing a source-set manifest. Document the contract so equivalent sets produce equivalent identities.

Foreign parser fingerprints

A GroundingSource adapter can expose a fingerprint when the foreign parser can bind evidence to exact source bytes or a documented canonical artifact. The adapter must state what the fingerprint represents.

If no fingerprint is available, Ethos can report the capability limitation. Applications should decide whether non-version-bound evidence can be released, reviewed, or rejected.

Never synthesize a fingerprint from a filename or timestamp and describe it as source-byte identity.

Fingerprint security considerations

• Use a modern approved hash such as the contract’s SHA-256.
• Obtain digests from trusted ingestion, not model output.
• Validate prefix and digest format.
• Compare expected and actual values consistently.
• Protect mappings between fingerprints and confidential documents.
• Prevent one tenant from probing another tenant’s source membership.
• Record hash-algorithm and contract version.
• Treat unexpected mismatch as investigation evidence, not retry noise.

Ethos’s determinism posture treats flaky fingerprints as bugs rather than retrying until a matching result appears.

Testing fingerprint behavior

Build fixtures for:

1. identical source bytes;
2. one-byte source change;
3. same filename with different bytes;
4. changed page selection or effective configuration;
5. runtime diagnostics that should not affect stable payload identity;
6. stable payload change that must affect fingerprint;
7. citation fingerprint match;
8. citation fingerprint mismatch;
9. required fingerprint missing from foreign source;
10. stale report containing textually matching checks;
11. source-set order normalization;
12. cache invalidation after source change.

Assert both fingerprint values and downstream verification/release behavior.

Audit and incident value

Fingerprints let investigators answer:

• which exact source content was used;
• whether the currently opened file is the same;
• which derived artifacts depend on that source;
• whether a citation request was stale at release time;
• which answers and caches require revalidation;
• whether a parser rerun changed stable evidence.

The Ethos auditability guide explains how fingerprints connect to verification reports and release records.

Definitive verdict

Ethos uses source fingerprints because citation verification without version identity is incomplete. A quote can be real and still belong to the wrong document revision. Fingerprints make source drift explicit, invalidate stale proof, and support reproducible parsing, CI, caching, and incident reconstruction.

Use DocuShell Parse PDF for source-aware artifacts, Ethos for fingerprint-bound citation checks, the deterministic RAG gate guide for release policy, and the DocuShell hallucination index for broader workflow-risk context.

Primary keyword: Ethos source fingerprints
Optimized meta title: Why Ethos Uses Source Fingerprints
Optimized meta description: Learn how Ethos source fingerprints detect stale citations, bind evidence to exact document versions, and support reproducible audits.
Proposed URL slug: why-does-ethos-use-source-fingerprints-for-citation-verification