Fact Verification Chains

Ensuring accuracy is critical in research workflows. Fact verification chains validate claims before they're included in final outputs.

The Verification Pipeline

Claim → Extract → Search for Evidence → Evaluate → Verdict → Report

Claim Extraction

Identifying Verifiable Claims

Prioritizing Claims for Verification

function prioritizeClaims(claims) {
  return claims.map(claim => {
    let priority = 0;

    // High impact claims need verification
    if (claim.isMainConclusion) priority += 3;
    if (claim.isStatistical) priority += 2;
    if (claim.isContradictory) priority += 2;

    // Easy to verify claims should be checked
    if (claim.hasSpecificSource) priority += 1;
    if (claim.isRecent) priority += 1;

    return { ...claim, priority };
  }).sort((a, b) => b.priority - a.priority);
}

Evidence Search

Targeted Verification Search

async function searchForEvidence(claim) {
  const strategies = [];

  // Strategy 1: Search for exact quote
  if (claim.type === 'attribution') {
    strategies.push(searchExactQuote(claim.attributedText));
  }

  // Strategy 2: Search authoritative sources
  strategies.push(searchAuthoritativeSources(claim.topic));

  // Strategy 3: Search fact-checking sites
  strategies.push(searchFactCheckers(claim.text));

  // Strategy 4: Search original source
  if (claim.citedSource) {
    strategies.push(verifyOriginalSource(claim.citedSource));
  }

  const results = await Promise.all(strategies);
  return aggregateEvidence(results);
}

Evidence Types

const evidenceTypes = {
  DIRECT: 'Original source confirms the claim directly',
  CORROBORATING: 'Different source confirms the same fact',
  CONTRADICTING: 'Source contradicts the claim',
  PARTIAL: 'Source confirms part of the claim',
  OUTDATED: 'Source is too old to be reliable',
  UNRELIABLE: 'Source is not trustworthy'
};

Evaluation Framework

Verdict Determination

Confidence Scoring

function calculateVerificationConfidence(evidence) {
  let score = 0;

  // Multiple sources agree
  const agreeing = evidence.filter(e => e.supports === true).length;
  score += agreeing * 0.2; // 0.2 per agreeing source

  // Source quality
  const highQualitySources = evidence.filter(e =>
    e.sourceType === 'academic' || e.sourceType === 'government'
  ).length;
  score += highQualitySources * 0.15;

  // Recency
  const recentEvidence = evidence.filter(e =>
    isRecent(e.date, { months: 24 })
  ).length;
  score += recentEvidence * 0.1;

  // Cap at 1.0
  return Math.min(score, 1.0);
}

Verification Chain Implementation

Complete Verification Flow

async function verificationChain(claims) {
  const results = [];

  for (const claim of claims) {
    // Step 1: Search for evidence
    const evidence = await searchForEvidence(claim);

    // Step 2: Evaluate evidence quality
    const qualityAssessment = await assessEvidenceQuality(evidence);

    // Step 3: Determine verdict
    const verdict = await determineVerdict(claim, evidence, qualityAssessment);

    // Step 4: Generate explanation
    const explanation = await generateExplanation(claim, verdict, evidence);

    results.push({
      claim,
      evidence: evidence.slice(0, 5), // Top 5 pieces of evidence
      verdict,
      explanation,
      confidence: calculateVerificationConfidence(evidence)
    });
  }

  return results;
}

Handling Unverifiable Claims

async function handleUnverifiable(claim) {
  return {
    claim,
    verdict: 'UNVERIFIABLE',
    reasons: [
      'No authoritative sources found',
      'Claim is about future events',
      'Claim requires access to private data'
    ],
    recommendation: 'Remove or add caveat',
    suggestedCaveat: `[This claim could not be independently verified]`
  };
}

Reporting Verification Results

Verification Summary

Exercise: Build a Verification Chain

Key Takeaways

• Extract and categorize claims before verification
• Prioritize high-impact and verifiable claims
• Search multiple source types for evidence
• Use a standardized verdict framework
• Calculate confidence based on evidence quality
• Handle unverifiable claims appropriately
• Generate clear verification reports
• Suggest corrections for false claims

In the next module, we'll build content pipelines for production use.