Contradiction Extraction Prompt for Research Briefs

This prompt is designed for analyst teams and AI systems that need to extract specific, contradictory claims from multiple source documents and produce a structured contradiction log. It is built for research brief workflows where evidence-backed reporting requires surfacing disagreements before synthesis. The primary job-to-be-done is transforming a set of topically related documents into an auditable, source-linked map of direct factual conflicts, enabling analysts to understand where the evidence diverges before they write a summary or recommendation.

The ideal user is an analyst, researcher, or AI pipeline operator who has already retrieved or collected a set of documents on the same topic and needs to identify where they directly conflict on factual claims. The prompt assumes the input documents share a common subject but may differ in conclusions, data, or reported findings. It is not designed to surface differences in scope, methodology, or framing—only direct contradictions where two or more sources cannot simultaneously be correct on a specific factual statement. The required inputs are a set of source documents with identifiers and a defined topic or question that bounds the extraction scope.

Do not use this prompt when the goal is to summarize consensus, rank sources by authority, or synthesize a unified answer from conflicting evidence. It is also inappropriate for single-document analysis, open-domain retrieval without pre-selected sources, or workflows where the output goes directly to end users without human review. The extracted contradictions require analyst verification before inclusion in a final brief, as the model may flag stylistic differences as conflicts or miss implicit contradictions that require domain expertise to detect. For downstream tasks like conflict resolution or evidence weighting, use this prompt's output as an intermediate artifact and pair it with the Conflict Resolution Decision Prompt or Source Reliability Weighting Prompt from this pillar.

Before running this prompt, ensure each source document has a stable identifier and that the document set is complete enough to surface meaningful contradictions. If the input set is too small or too homogenous, the prompt will return an empty or sparse log—which is a valid outcome, not a failure. After extraction, validate the output by spot-checking whether flagged contradictions are genuine direct conflicts rather than differences in scope, population, or timeframe. Common failure modes include flagging paraphrased agreement as contradiction, missing contradictions that require numerical comparison, and extracting contradictions on peripheral claims while missing central disputes. Wire the output into a human review queue before it reaches any synthesis or publishing step.

This section provides the core prompt for the Contradiction Extraction workflow. The template is designed to be dropped into an AI harness that supplies the source documents, claim scope, and output schema. It forces the model to extract only direct contradictions—not differences in methodology, scope, or terminology—and to pair each contradiction with exact source citations. Use this template as the starting point; the surrounding harness should handle document chunking, citation resolution, and output validation before any contradiction log reaches an analyst.

textCopy
You are a contradiction extraction specialist. Your task is to identify direct, specific contradictions between the provided source documents and produce a structured contradiction log.

## INPUT DOCUMENTS
[DOCUMENTS]

## CLAIM SCOPE
[CLAIM_SCOPE]

## INSTRUCTIONS
1. Read all provided documents carefully.
2. Identify claims where two or more documents make statements that cannot all be true at the same time.
3. A contradiction exists only when the statements are about the same specific fact, metric, event, or finding. Do not flag differences in:
   - Scope (e.g., one study covers US, another covers EU)
   - Methodology (e.g., different measurement techniques)
   - Time period (e.g., 2022 data vs. 2023 data) unless the temporal difference itself is the contradiction
   - Terminology or definitions unless they produce factual conflict
4. For each contradiction, extract the exact conflicting statements from each source.
5. Provide precise citations including document identifier and, where available, section or paragraph reference.
6. Classify the contradiction type using only these categories:
   - FACTUAL: Direct conflict on a verifiable fact or metric
   - INTERPRETATION: Same evidence, different conclusions
   - PREDICTION: Conflicting forecasts or projections
   - OMISSION: One source asserts a fact that another source should include but does not
7. Assign a severity rating: HIGH (material impact on conclusions), MEDIUM (notable but not decision-changing), LOW (minor discrepancy).
8. If no contradictions are found, return an empty log with a brief explanation of why.

## OUTPUT SCHEMA
Return a JSON object with this exact structure:
{
  "contradictions": [
    {
      "id": "string",
      "claim": "string (the specific disputed claim)",
      "type": "FACTUAL | INTERPRETATION | PREDICTION | OMISSION",
      "severity": "HIGH | MEDIUM | LOW",
      "positions": [
        {
          "source_id": "string",
          "citation": "string (section, paragraph, or page reference)",
          "statement": "string (exact quoted or closely paraphrased statement)",
          "position_summary": "string (one-sentence summary of what this source claims)"
        }
      ],
      "analysis": "string (brief explanation of why this is a contradiction, not a scope or methodology difference)",
      "resolvability": "RESOLVABLE | PARTIALLY_RESOLVABLE | UNRESOLVABLE",
      "resolution_note": "string or null (if resolvable, note what additional evidence or clarification would resolve it)"
    }
  ],
  "no_contradictions_found": false,
  "no_contradictions_explanation": null,
  "total_documents_reviewed": 0,
  "total_contradictions_found": 0
}

## CONSTRAINTS
- Do not fabricate contradictions. If documents agree or discuss different things, do not force a conflict.
- Do not cite a source for a claim it does not explicitly make.
- If a contradiction involves more than two sources, include all conflicting positions in the positions array.
- Keep statements under 200 words each; prefer direct quotes where possible.
- If [RISK_LEVEL] is HIGH, flag any contradiction that could affect safety, compliance, or regulatory standing with an additional "risk_flag": true field.

To adapt this template, replace [DOCUMENTS] with your pre-chunked and citation-mapped source passages. The [CLAIM_SCOPE] placeholder should describe the domain or specific claims under review—for example, 'clinical efficacy claims about Drug X' or 'market size estimates for the EV battery sector.' The [RISK_LEVEL] placeholder accepts HIGH, MEDIUM, or LOW and controls whether risk-flagging fields are activated. In your harness, inject these variables before sending the prompt. After receiving the output, validate the JSON structure, verify that each citation resolves to an actual document span, and run a secondary check: for each contradiction, confirm that the conflicting statements are about the same specific fact. If the output contains contradictions flagged as HIGH severity or with risk_flag set to true, route to human review before the contradiction log is finalized. Do not skip validation—models will occasionally flag paraphrased agreement as contradiction or miss implicit conflicts that require domain knowledge.

The Contradiction Extraction Prompt is designed to be called programmatically as part of a research briefing pipeline. It expects a set of pre-segmented document passages, each with a stable identifier, and returns a structured contradiction log. The prompt is not a chat interface; it should be invoked with a strict system message and a single user turn containing the formatted input. The model should be configured with a low temperature (0.0–0.2) to maximize deterministic extraction, and the output must be validated against the expected JSON schema before it enters any downstream system.

Integration pattern: Place this prompt behind an API endpoint or a queue worker that receives a batch of passages. The caller must supply a [DOCUMENTS] array where each object includes id, text, and optional metadata (e.g., publication date, author, source type). The prompt template uses these fields to generate a contradiction log with claim_1, claim_2, source_1_id, source_2_id, conflict_type, and explanation fields. Validation layer: After the model responds, parse the JSON output and run a schema validator. Reject any output where source_1_id equals source_2_id (self-contradiction), where extracted claims are paraphrases rather than direct conflicts, or where conflict_type is not one of the allowed enum values (factual, methodological, interpretation, scope, temporal). Retry logic: If validation fails, re-invoke the prompt once with the validation errors appended as a [CORRECTION_NOTES] field. If the second attempt also fails, log the raw output and escalate for human review rather than silently accepting a malformed contradiction log.

Model choice and tool use: This prompt works best with models that have strong instruction-following and structured output capabilities (e.g., GPT-4o, Claude 3.5 Sonnet). Do not use a model that lacks reliable JSON mode for this task. If your platform supports native structured output or tool calling, define a tool schema matching the contradiction log format and require the model to call it; this reduces parsing errors. RAG integration: If passages are retrieved from a vector store or search index, ensure each passage carries its source identifier through the retrieval pipeline. The contradiction extraction step should run after retrieval and before synthesis, so that downstream answer generation can incorporate the conflict log. Logging and audit: Store every contradiction extraction result with the model version, prompt version, input passage IDs, and validation outcome. This audit trail is essential for debugging false positives and for compliance workflows where contradiction handling must be explainable.

Human review triggers: Automatically escalate to human review when the contradiction log exceeds a configurable threshold (e.g., more than 10 contradictions in a single batch), when conflict_type distribution is unexpectedly skewed, or when the model's finish reason indicates truncation or content filtering. For high-stakes domains such as legal or medical research briefs, require human sign-off on all extracted contradictions before they are presented to end users. What to avoid: Do not feed the entire document corpus into a single prompt call if it exceeds the model's context window; chunk the input and merge results with deduplication logic. Do not treat the contradiction log as ground truth without verification—always spot-check a sample against source passages. Finally, do not use this prompt as a substitute for source reliability assessment; pair it with a separate source authority scoring step to avoid flagging trivial disagreements between high-authority and low-authority sources as meaningful conflicts.