Temporal Contradiction Detection Prompt

This prompt is designed for evidence conflict resolution and fact-checking system builders who need to distinguish genuine contradictions from temporal progression when multiple sources report different facts, figures, or events for the same time period. The ideal user is an AI engineer or pipeline architect integrating this into a production system where source disagreement must be surfaced rather than silently resolved. You need this when your retrieval set contains documents that appear to conflict—one source says revenue was $4.2B while another says $3.8B for the same quarter—and you must determine whether this is a real discrepancy requiring human review or simply one source reporting preliminary results before a later revision.

Use this prompt when you have at least two sources covering the same temporal scope and you need a structured contradiction report with source comparison and resolution recommendations. The prompt expects pre-retrieved evidence passages with known publication dates, source identifiers, and the specific claims or figures in question. It works best when the temporal scope is explicit—a specific quarter, day, event, or reporting period—rather than vague time references. Do not use this prompt for general fact-checking against a knowledge base, for single-source verification, or when the temporal relationship between sources is unknown. It is not a replacement for temporal relevance scoring or recency-aware ranking; those are upstream concerns that should filter and order evidence before contradiction detection runs.

The prompt produces a structured contradiction report that classifies each conflict as genuine contradiction, temporal progression, reporting lag, definitional difference, or correction. For each conflict, it identifies the conflicting claims, the sources, their publication dates, and a resolution recommendation. This output is designed to feed into downstream human review queues, automated fact-checking dashboards, or evidence synthesis prompts that need to know which sources to trust. The resolution recommendations are advisory—they suggest which source is likely more authoritative or current—but the prompt explicitly avoids making final determinations that should require human judgment, especially for high-stakes domains like financial reporting or clinical data.

Before deploying this prompt, ensure your retrieval pipeline has already selected temporally relevant passages and extracted publication dates. The prompt assumes clean date metadata; garbage dates produce garbage contradiction classifications. You should also implement a validation layer that checks the output schema, verifies that every flagged conflict cites specific sources and claims, and escalates reports with high-severity contradictions to human review. For regulated domains, always require human approval before acting on contradiction reports. The test harness included in this playbook covers known temporal conflict scenarios—preliminary vs. final earnings, corrected press releases, timezone edge cases, and definitional mismatches—so run those evals before shipping.

This section provides a copy-ready prompt template for detecting when multiple sources report conflicting facts, figures, or events for the same time period. The template is designed to distinguish genuine contradictions—where sources disagree about what happened at a specific point in time—from temporal progression, where newer sources update or supersede older information. Use this prompt when you need to surface conflicts in evidence sets before generating answers, produce structured contradiction reports for downstream resolution, or build automated fact-checking pipelines that must identify temporal discrepancies.

The prompt template below uses square-bracket placeholders for all variable inputs. Replace each placeholder with your application's actual values before sending the prompt to the model. The template expects a set of source passages with publication dates, a target time period or claim to evaluate, and an output schema specification. It instructs the model to compare sources pairwise, identify contradictions, classify their type, and recommend resolution actions. The prompt includes explicit instructions for handling edge cases such as missing dates, partial temporal overlap, and sources that describe different aspects of the same event without actually conflicting.

textCopy
You are a temporal contradiction detection system. Your task is to analyze multiple source passages and identify genuine contradictions—where sources disagree about facts, figures, or events for the same time period—while distinguishing these from temporal progression where newer information updates older information.

## INPUT

**Target Time Period or Claim:** [TARGET_TIME_PERIOD_OR_CLAIM]

**Source Passages:**
[SOURCE_PASSAGES]
- Format: Each source must include a unique ID, publication date, and full text.
- Example: [SOURCE_ID] | [PUBLICATION_DATE] | [SOURCE_TEXT]

**Domain Context:** [DOMAIN_CONTEXT]
- Describe the domain, expected rate of change, and any known data revision patterns.

## OUTPUT SCHEMA

Return a JSON object with the following structure:

[OUTPUT_SCHEMA]
- Example fields: contradictions (array), temporal_progressions (array), unresolved (array), resolution_recommendations (array), confidence_scores (object)

## CONSTRAINTS

[CONSTRAINTS]
- Example: Do not flag sources as contradictory if they describe different time points within the target period.
- Example: Treat a newer source that explicitly supersedes an older source as temporal progression, not contradiction.
- Example: Flag as unresolved any conflict where neither source has clear authority or corroboration.

## EXAMPLES

[EXAMPLES]
- Provide 2-3 few-shot examples showing input source sets and correct contradiction detection outputs.
- Include both clear contradiction cases and temporal progression cases.

## INSTRUCTIONS

1. Parse all source passages and extract their publication dates and key factual claims relevant to the target time period.
2. Group claims by the specific time point or event they describe.
3. For each group, compare claims across sources pairwise.
4. Classify each comparison as:
   - **contradiction**: Sources disagree on facts for the same time point.
   - **temporal_progression**: A newer source updates or supersedes an older source.
   - **complementary**: Sources describe different aspects without conflict.
   - **unresolved**: Insufficient information to determine the relationship.
5. For each contradiction, identify the specific conflicting claims, the sources involved, and the type of contradiction (factual, numerical, event description, attribution).
6. For each temporal progression, note which source supersedes which and why.
7. Generate resolution recommendations: which source to prefer, whether to seek additional sources, or whether to present both versions to the user with uncertainty.
8. Assign confidence scores to each classification.
9. Return the complete analysis in the specified output schema.

## RISK LEVEL

[RISK_LEVEL]
- If HIGH: Flag all contradictions for human review before any downstream use.
- If MEDIUM: Auto-resolve clear temporal progressions; flag contradictions for review.
- If LOW: Auto-resolve where confidence exceeds threshold; log all decisions.

After copying the template, replace the placeholders with your application's actual values. For [SOURCE_PASSAGES], ensure each source includes a reliable publication date—sources without dates should be flagged in preprocessing rather than passed to the model. For [OUTPUT_SCHEMA], define a JSON schema that your downstream systems can parse and act on. For [CONSTRAINTS], add domain-specific rules such as 'financial restatements supersede original filings' or 'peer-reviewed sources take precedence over preprints for the same time period.' For [EXAMPLES], curate few-shot examples from your actual domain to improve accuracy. For [RISK_LEVEL], set the threshold based on your use case's tolerance for unresolved contradictions reaching end users. Always validate the model's output against your schema before passing results downstream, and log contradiction reports for audit and model improvement.

The Temporal Contradiction Detection Prompt is designed to operate as a post-retrieval analysis step in a fact-checking or evidence conflict resolution pipeline. It should not be called directly on raw user input. Instead, feed it a curated set of temporally-scoped evidence passages that have already passed through relevance and freshness filters. The prompt expects a structured [CLAIM] under investigation and a [SOURCE_SET] containing at least two sources with explicit publication dates or temporal markers. Without these inputs, the model cannot distinguish genuine contradictions from temporal progression.

Wiring the prompt into an application requires a wrapper that performs pre-validation, model invocation, and post-processing. Before calling the model, validate that [SOURCE_SET] contains at least two entries, each with a non-null date field and a unique source_id. If the input fails validation, return a structured error to the caller rather than invoking the model. After receiving the model's response, parse the JSON output and run a schema validator that checks for required fields: contradiction_detected (boolean), contradiction_type (enum: genuine_contradiction, temporal_progression, methodological_difference, no_contradiction), conflicting_sources (array of source_id pairs), resolution_recommendation (string), and confidence_score (float 0-1). If the model output fails schema validation, implement a single retry with the validation error message appended to the prompt as [PREVIOUS_ERROR]. After two consecutive failures, escalate to a human review queue with the original inputs and both failed outputs attached.

Model choice and tool use matter here. This prompt benefits from models with strong reasoning capabilities (GPT-4, Claude 3.5 Sonnet, or equivalent) because temporal contradiction detection requires comparing multiple fact patterns across time. Do not use lightweight or local models for this task unless you have calibrated their performance against a labeled contradiction dataset. The prompt does not require external tools or RAG at runtime—it operates on pre-retrieved evidence. However, you should log every invocation with: claim_id, source_set_hash, model_version, output_contradiction_type, confidence_score, and latency_ms. This logging enables regression testing when the prompt or model changes. For high-stakes domains (financial reporting, legal evidence, clinical claims), always route genuine_contradiction outputs with confidence_score < 0.85 to a human analyst before surfacing results to end users.

Common failure modes to monitor in production: (1) The model conflates temporal progression with contradiction when sources report different figures for different time periods—mitigate by ensuring each source in [SOURCE_SET] has a precise reporting_period field. (2) The model misses contradictions when sources use different units, currencies, or measurement methodologies—add a [NORMALIZATION_NOTES] field to the input schema. (3) Confidence scores drift upward over time as the model becomes overconfident on familiar patterns—run periodic calibration checks against a golden dataset of known temporal conflicts. Build a dashboard that tracks contradiction detection rate, human override rate, and confidence score distribution by contradiction type. If the human override rate exceeds 15%, revisit your input schema, prompt instructions, or model selection.