The Decomposition Tax 2026: Mengapa Multi-Stage LLM Pipelines Kehilangan Hingga 40 Poin Akurasi pada Interface Antar-Tahap, Empirical Diagnosis pada 21 Model, dan Dua Resep Preskriptif Perbaikan

// Production Implementation: Re-Grounding & Relational Preservation Engine
// Berdasarkan Prinsip Arsitektur Riset arXiv:2609.32825 (Bu et al. - September 2026)
//
// Mengatasi "The Decomposition Tax" pada multi-stage LLM pipelines:
// 1. RelationalPreservingExtractor: Menjamin relasi logis dipertahankan saat ekstraksi
// 2. PostLossReGrounder: Menginjeksikan problem asli tepat setelah antarmuka lossy (Stage > Loss)
// 3. DecompositionTaxAuditor: Mengukur degradasi delta akurasi: acc(Full) - acc(Strict)

export interface PipelineStageConfig {
  stageId: string;
  stageName: 'EXTRACT' | 'PLAN' | 'SOLVE' | 'VERIFY';
  isLossyInterfacePreceding: boolean;
  enforceReGrounding: boolean;
  preserveRelationalSemantics: boolean;
}

export interface PipelineExecutionContext {
  originalProblem: string;
  stageOutputs: Map;
  tokenBudget: number;
}

export interface StagePayload {
  role: 'system' | 'user';
  content: string;
}

/**
 * 1. Relational-Preserving Stage Instruction Compiler
 * Mengeliminasi pereduksian agresif (condensing list) yang menghilangkan koneksi antar-variabel
 */
export class RelationalInstructionCompiler {
  public static compileExtractionPrompt(baseInstruction: string, preserveRelations: boolean): string {
    if (!preserveRelations) {
      // Condensing list (baseline rentan: memicu tax rata-rata +15.16 poin)
      return `${baseInstruction}\nExtract the numerical quantities given and exactly what is asked as a clean structured list.`;
    }

    // Preserving specification (menurunkan tax pada 9 dari 9 model di MATH-500)
    return `${baseInstruction}\nExtract the numerical quantities given, exactly what is asked, and EVERY RELATIONSHIP STATED BETWEEN THEM as a cohesive plain-prose restatement in your own words.`;
  }

  public static compileReceiverPrompt(baseInstruction: string, allowReDerivation: boolean): string {
    if (!allowReDerivation) {
      // Committed receiver (terkunci pada input sebelumnya tanpa ruang koreksi)
      return `${baseInstruction}\nOutput only the final expression(s) to compute.`;
    }

    // Re-deriving receiver (memberikan ruang eksplorasi langkah demi langkah)
    return `${baseInstruction}\nReason step by step, re-evaluate constraints, and then write the arithmetic expression(s). End with the expression(s) to compute.`;
  }
}

/**
 * 2. Post-Loss Targeted Re-Grounder
 * Menempatkan re-grounding masalah asli TEPAT SETELAH interface yang lossy.
 * Berdasarkan Teorema Empiris Bu et al.: Re-grounding sebelum loss merugikan (negative recovery pada 7/7 model),
 * sementara re-grounding setelah loss memulihkan hingga 65% akurasi yang hilang.
 */
export class PostLossReGrounder {
  public static assembleStageInput(
    context: PipelineExecutionContext,
    stageConfig: PipelineStageConfig,
    previousStageOutput: string
  ): StagePayload[] {
    const messages: StagePayload[] = [];

    // System prompt dasar
    messages.push({
      role: 'system',
      content: `You are executing stage [${stageConfig.stageName}]. Reason strictly over the provided context.`
    });

    let contextPayload = '';

    // Targeted Re-Grounding Gate:
    // Hanya disisipkan jika stageConfig menandai kebutuhan re-grounding pasca antarmuka lossy
    if (stageConfig.enforceReGrounding && stageConfig.isLossyInterfacePreceding) {
      contextPayload += `=== Original problem (for reference) ===\n${context.originalProblem}\n\n`;
    }

    contextPayload += `=== Output from previous stage ===\n${previousStageOutput}`;

    messages.push({
      role: 'user',
      content: contextPayload
    });

    return messages;
  }
}

/**
 * 3. Decomposition Tax Auditor & Pipeline Harness
 * Menguji apakah pipeline Anda membayar 'pajak dekomposisi' dan mengukur efikasi re-grounding
 */
export class PipelineTaxAuditor {
  private runsStrict: number = 0;
  private correctStrict: number = 0;
  private runsFull: number = 0;
  private correctFull: number = 0;

  public recordStrictResult(isCorrect: boolean): void {
    this.runsStrict++;
    if (isCorrect) this.correctStrict++;
  }

  public recordFullResult(isCorrect: boolean): void {
    this.runsFull++;
    if (isCorrect) this.correctFull++;
  }

  public computeTaxMetrics(): {
    strictAccuracy: number;
    fullAccuracy: number;
    decompositionTax: number;
    recoveryFractionVsMonolith: number;
  } {
    const accStrict = this.runsStrict > 0 ? this.correctStrict / this.runsStrict : 0;
    const accFull = this.runsFull > 0 ? this.correctFull / this.runsFull : 0;
    const tax = accFull - accStrict;

    return {
      strictAccuracy: Number((accStrict * 100).toFixed(2)),
      fullAccuracy: Number((accFull * 100).toFixed(2)),
      decompositionTax: Number((tax * 100).toFixed(2)),
      recoveryFractionVsMonolith: tax > 0 ? Number(((tax / accFull) * 100).toFixed(1)) : 0
    };
  }
}