How Do You Verify Page Numbers, Quotes, and Table Cells in AI Citations?

Direct answer

Verify page numbers, quotes, and table cells in AI citations by testing a structured evidence proposition against a versioned source. Start with the document fingerprint, then resolve the exact page, element, quotation, table, row, column, cell, value, and relevant context. Fail when the locator is wrong, the evidence differs, the source is stale, or the parser lacks the capability needed to prove the claim.

Do not search the entire document for similar text and call the original citation correct. If a quote exists on page 19 but the AI cited page 18, the citation failed. A correction can be generated separately, but the original error must remain visible in the report.

This guide covers deterministic evidence integrity. Whether the verified evidence semantically supports the answer is a separate claim-level evaluation described in the claim-level citation verification guide.

Start with one evidence envelope

Pages, quotes, and cells should share a source-bound envelope:

{
  "request_id": "verify-0194",
  "source_id": "annual-report-2025",
  "document_fingerprint": "sha256:governed-source-digest",
  "claims": [
    {
      "id": "v-page-quote",
      "kind": "quote",
      "page_index": 17,
      "page_label": "18",
      "element_id": "p17-e42",
      "expected_text": "Revenue was $12.4 million for the quarter."
    },
    {
      "id": "v-table-cell",
      "kind": "table_cell",
      "page_index": 17,
      "table_id": "p17-table-2",
      "row_label": "Revenue",
      "column_label": "Q3 2025",
      "cell_id": "p17-t2-r4-c2",
      "expected_value": "12400000",
      "unit": "USD"
    }
  ]
}

The envelope states exactly what must be true. A verifier should not guess missing locators or substitute nearby evidence during the check.

Verification order matters

Use a stable order:

validate citation schema
  -> authorize source access
  -> resolve trusted source
  -> compare source fingerprint
  -> check required source capability
  -> resolve page
  -> resolve element, quote, table, cell, or region
  -> compare expected evidence
  -> emit structured result and limitations

Earlier failures constrain later claims. If the source fingerprint is stale, a text match should not become reusable proof. If the source has no table model, digits found in flat page text should not satisfy a table-cell request.

How to verify AI citation page numbers

Page verification has at least four identities:

1. source document;
2. machine page index;
3. printed page label;
4. evidence located on the page.

Machine page index versus printed page label

PDF viewers usually expose a physical page sequence, while documents may print Roman numerals, restart numbering, omit cover pages, or use Bates labels. Store the machine index and human-facing label separately.

Never assume these are numerically equal.

Page verification checks

1. The source fingerprint matches.
2. The page index is within [0, page_count).
3. The stored page-label map agrees with the requested label.
4. The cited element, text, table, or region belongs to that page.
5. Page geometry and rotation are known when coordinates are used.

Confirming only that page 17 exists is not sufficient. The page must contain the submitted evidence target.

Common page failures

• one-based page entered as zero-based index;
• cover pages shift printed numbering;
• an updated document inserts front matter;
• OCR output creates artificial pages;
• a chunk spans pages but inherits only one page number;
• a source link opens a new version while the citation references old pagination;
• coordinates are reused after rotation or crop changes.

Report page-not-found, label mismatch, stale source, and evidence-on-wrong-page as distinguishable reasons.

How to verify AI-generated quotations

Quote verification should be exact under a documented normalization profile. Raw byte equality is often too strict because PDF extraction can change line breaks, ligatures, and Unicode representation. Fuzzy semantic similarity is too permissive for evidence integrity.

Safe bounded normalization

Depending on the contract, a verifier may normalize:

• Unicode normalization form;
• line-ending conventions;
• repeated ASCII whitespace;
• known extraction-only line breaks;
• explicitly defined soft-hyphen behavior.

It should not silently remove:

• not, except, or modal verbs;
• minus signs or parentheses;
• currency and percentage symbols;
• decimal points;
• dates and units;
• section numbers;
• punctuation that changes scope;
• words merely because they appear “close enough.”

A bounded quote-normalization example

import re
import unicodedata


ASCII_WHITESPACE = re.compile(r"[\t\n\r\f\v ]+")


def normalize_evidence_quote(value: str) -> str:
    if not isinstance(value, str) or not value.strip():
        raise ValueError("Evidence quote must be a non-empty string")
    normalized = unicodedata.normalize("NFC", value)
    normalized = normalized.replace("\r\n", "\n").replace("\r", "\n")
    return ASCII_WHITESPACE.sub(" ", normalized).strip()


def quote_matches(expected: str, observed: str) -> bool:
    return normalize_evidence_quote(expected) == normalize_evidence_quote(observed)


assert quote_matches("must\nnot exceed", "must not   exceed")
assert not quote_matches("must not exceed", "may exceed")

Do not add case folding or punctuation removal without a source-specific, reviewed reason. Preserve the normalization version in the report so old results can be reproduced.

Match within the resolved target

Search the cited element or bounded page region, not the entire corpus. Repeated policy boilerplate may appear on many pages. A document-wide match cannot prove the submitted locator.

For substring claims, record the observed start and end offsets under a stable text representation. If offsets are not stable, cite the containing element plus expected quote.

How to verify table-cell citations

Table evidence is structural. A cell inherits meaning from row and column headers, units, title, notes, and sometimes merged parent headers.

For this table:

The digits 12.4 prove nothing alone. A complete cell claim includes:

• source and fingerprint;
• page and table identity;
• row path: Revenue;
• column path: Q3 2025;
• displayed value: 12.4;
• normalized value: 12400000;
• currency: USD;
• scale: 1000000;
• relevant table title and footnotes.

Table-cell verification checks

1. The source declares structured table capability.
2. The table ID resolves on the cited page.
3. Row and column paths resolve uniquely.
4. The cell ID belongs to their intersection.
5. Displayed and normalized values agree under explicit unit and scale rules.
6. Merged headers and footnote markers are preserved.
7. The cited period, entity, category, and dimension match the claim.

Finding 12.4 elsewhere on the page is not a substitute.

Typed value comparison

Use decimal or domain-specific types rather than binary floating-point for exact financial evidence.

from decimal import Decimal, InvalidOperation


def normalize_table_decimal(
    displayed: str,
    *,
    scale: Decimal,
    negative_parentheses: bool = True,
) -> Decimal:
    value = displayed.strip().replace(",", "")
    negative = negative_parentheses and value.startswith("(") and value.endswith(")")
    if negative:
        value = value[1:-1].strip()
    try:
        parsed = Decimal(value)
    except InvalidOperation as exc:
        raise ValueError(f"Invalid table value: {displayed!r}") from exc
    if not parsed.is_finite():
        raise ValueError("Table value must be finite")
    return (-parsed if negative else parsed) * scale


assert normalize_table_decimal("12.4", scale=Decimal("1000000")) == Decimal("12400000.0")
assert normalize_table_decimal("(2.1)", scale=Decimal("1000000")) == Decimal("-2100000.0")

The caller must obtain scale from verified table context. Never guess that a financial table uses thousands or millions.

Capability-aware verification

A grounding source should declare what it can prove.

Ethos consumes evidence through GroundingSource. Native Ethos JSON and supported foreign-parser adapters expose different capabilities. The verifier reports missing capabilities rather than upgrading plain text into stronger proof.

Distinguish mismatch, not found, and stale

Do not reduce these to a single zero. Each result points to a different remediation.

Verify regions and crops for human inspection

Coordinates should include:

• page identity;
• page width and height;
• coordinate origin;
• units;
• rotation handling;
• bounded [x0, y0, x1, y1] geometry;
• source fingerprint.

A crop is review evidence, not the canonical source. Bind its descriptor to the verification check and original PDF. Renderer differences can affect PNG bytes, so do not claim cross-platform image-byte identity unless it is specifically validated.

End-to-end release policy

For each claim:

1. require all mandatory citation checks;
2. reject stale fingerprints;
3. require exact page and target resolution;
4. require quote, value, or cell match;
5. route capability-limited evidence to review;
6. evaluate semantic support separately;
7. recompute calculations;
8. release only claim text whose required gates pass.

The Ethos citation verification guide explains how the canonical report and proof summary fit this policy.

Test matrix

Add repeated quotations, merged cells, multi-page tables, rotated pages, page-label restarts, OCR decimal errors, and unit-scale changes.

The definitive verdict

Page numbers, quotes, and table cells are verifiable only when citations identify an exact, versioned evidence target. Page checks need machine and human numbering; quote checks need bounded, versioned normalization; table checks need structural row, column, unit, scale, and period context.

Use Ethos to perform supported deterministic evidence checks, preserve capability limitations, and retain the canonical report. Then evaluate semantic relevance and calculations separately. The result is stronger than “the text appears somewhere”: it proves whether the submitted citation points to the exact source evidence it claims.

Primary keyword: verify AI citation page numbers Optimized meta title: Verify Pages, Quotes, and Tables in AI Citations Optimized meta description: Verify AI citation pages, quotes, and table cells with source fingerprints, bounded normalization, structured locators, and capability checks. Proposed URL slug: how-do-you-verify-page-numbers-quotes-and-table-cells-in-ai-citations