verifiable-thinking-mcp 0.4.0

package/src/lib/compute/solvers/derivation-core.ts

@@ -0,0 +1,371 @@
+/**
+ * Derivation Core - verifies multi-step algebraic derivations
+ *
+ * Uses compareExpressions to check that each step in a derivation is
+ * algebraically equivalent to the previous step. Catches "magic" steps
+ * in proofs where the transformation isn't valid.
+ *
+ * @module derivation-core
+ */
+
+import { compareExpressions } from "../../verification.ts";
+import type { ComputeResult } from "../types.ts";
+
+/** Result of verifying a single derivation step */
+export interface StepVerification {
+  step: number;
+  lhs: string;
+  rhs: string;
+  valid: boolean;
+  error?: string;
+}
+
+/** Result of verifying a complete derivation */
+export interface DerivationResult {
+  valid: boolean;
+  steps: StepVerification[];
+  invalidStep?: number;
+  error?: string;
+}
+
+/**
+ * Extract derivation steps from text
+ * Looks for patterns like:
+ *   expr1 = expr2
+ *   expr3 = expr4
+ *   ...
+ *
+ * Or chained: expr1 = expr2 = expr3 = ...
+ *
+ * Or sentence-separated: expr1 = expr2, then expr3 = expr4
+ */
+export function extractDerivationSteps(text: string): Array<{ lhs: string; rhs: string }> {
+  const steps: Array<{ lhs: string; rhs: string }> = [];
+
+  // Pre-process: split on sentence boundaries (comma, semicolon, "then", "so", etc.)
+  // to handle multi-step derivations in a single line
+  const segments = text
+    .split(/[,;]|\bthen\b|\bso\b|\btherefore\b|\bhence\b/i)
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  // Process each segment
+  for (const segment of segments) {
+    // Pattern 1: Chained equalities (a = b = c = d)
+    // Split on "=" and pair consecutive terms
+    const chainedMatch = segment.match(
+      /([^=\n]+(?:=[^=\n]+){2,})/g, // 3+ terms connected by =
+    );
+
+    if (chainedMatch) {
+      for (const chain of chainedMatch) {
+        const parts = chain
+          .split("=")
+          .map((p) => cleanExpressionPart(p))
+          .filter(Boolean);
+        for (let i = 0; i < parts.length - 1; i++) {
+          const lhs = parts[i];
+          const rhs = parts[i + 1];
+          if (lhs && rhs) {
+            steps.push({ lhs, rhs });
+          }
+        }
+      }
+      continue; // Move to next segment
+    }
+
+    // Pattern 2: Simple equality (expr = expr)
+    const simpleMatch = segment.match(/^\s*([^=\n]+?)\s*=\s*([^=\n]+?)\s*$/);
+    if (simpleMatch) {
+      const lhs = cleanExpressionPart(simpleMatch[1] ?? "");
+      const rhs = cleanExpressionPart(simpleMatch[2] ?? "");
+      if (lhs && rhs) {
+        steps.push({ lhs, rhs });
+      }
+    }
+  }
+
+  // If no steps found via segment processing, try original line-by-line approach
+  if (steps.length === 0) {
+    // Pattern 3: Line-by-line equalities
+    const linePattern = /^\s*([^=\n]+?)\s*=\s*([^=\n]+?)\s*$/gm;
+    let match: RegExpExecArray | null;
+    while ((match = linePattern.exec(text)) !== null) {
+      const lhs = cleanExpressionPart(match[1] ?? "");
+      const rhs = cleanExpressionPart(match[2] ?? "");
+      if (lhs && rhs) {
+        steps.push({ lhs, rhs });
+      }
+    }
+  }
+
+  return steps;
+}
+
+/**
+ * Clean an expression part by removing non-math prefixes
+ * E.g., "prove: x + x" → "x + x"
+ */
+export function cleanExpressionPart(part: string): string {
+  let cleaned = part.trim();
+
+  // Remove common prefixes like "prove:", "show that", "verify:", etc.
+  cleaned = cleaned.replace(
+    /^(?:prove|show(?:\s+that)?|verify|therefore|thus|hence|so|then)[:.]?\s*/i,
+    "",
+  );
+
+  // Remove leading non-math characters (but keep negative signs)
+  // Match from start: letters/punctuation that aren't part of a variable
+  cleaned = cleaned.replace(/^[^a-zA-Z0-9\-.(]+/, "");
+
+  return cleaned.trim();
+}
+
+/**
+ * Verify that each step in a derivation is algebraically valid
+ *
+ * For each step "A = B", we verify:
+ * 1. A and B are equivalent (within the same step)
+ *
+ * For consecutive steps, we verify:
+ * 2. The RHS of step N equals the LHS of step N+1 (continuity)
+ *
+ * @param steps Array of {lhs, rhs} pairs representing the derivation
+ * @returns DerivationResult with validity and error details
+ */
+export function verifyDerivationSteps(
+  steps: Array<{ lhs: string; rhs: string }>,
+): DerivationResult {
+  if (steps.length === 0) {
+    return { valid: false, steps: [], error: "No derivation steps found" };
+  }
+
+  const verifiedSteps: StepVerification[] = [];
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    if (!step) continue;
+
+    const { lhs, rhs } = step;
+    const stepNum = i + 1;
+
+    // Check 1: LHS and RHS of this step are equivalent
+    const equivalent = compareExpressions(lhs, rhs);
+
+    if (!equivalent) {
+      verifiedSteps.push({
+        step: stepNum,
+        lhs,
+        rhs,
+        valid: false,
+        error: `Step ${stepNum}: "${lhs}" is not equivalent to "${rhs}"`,
+      });
+      return {
+        valid: false,
+        steps: verifiedSteps,
+        invalidStep: stepNum,
+        error: `Invalid step ${stepNum}: ${lhs} ≠ ${rhs}`,
+      };
+    }
+
+    // Check 2: Continuity with previous step
+    // The LHS of this step should equal the RHS of the previous step
+    if (i > 0) {
+      const prevStep = steps[i - 1];
+      if (prevStep) {
+        const continuous = compareExpressions(prevStep.rhs, lhs);
+        if (!continuous) {
+          verifiedSteps.push({
+            step: stepNum,
+            lhs,
+            rhs,
+            valid: false,
+            error: `Step ${stepNum} doesn't follow from step ${stepNum - 1}: "${prevStep.rhs}" → "${lhs}"`,
+          });
+          return {
+            valid: false,
+            steps: verifiedSteps,
+            invalidStep: stepNum,
+            error: `Discontinuity at step ${stepNum}: previous RHS "${prevStep.rhs}" ≠ current LHS "${lhs}"`,
+          };
+        }
+      }
+    }
+
+    verifiedSteps.push({
+      step: stepNum,
+      lhs,
+      rhs,
+      valid: true,
+    });
+  }
+
+  return {
+    valid: true,
+    steps: verifiedSteps,
+  };
+}
+
+/**
+ * Try to verify a derivation in text
+ *
+ * Extracts derivation steps and verifies each one is algebraically valid.
+ * Useful for checking mathematical proofs and simplification chains.
+ *
+ * @example
+ * // Valid derivation
+ * tryDerivation("x + x = 2x = 2*x")
+ * // { solved: true, result: "Valid derivation (2 steps)", ... }
+ *
+ * @example
+ * // Invalid derivation
+ * tryDerivation("x + x = 2x = 3x")
+ * // { solved: true, result: "Invalid step 2: 2x ≠ 3x", ... }
+ */
+export function tryDerivation(text: string): ComputeResult {
+  const start = performance.now();
+  const lower = text.toLowerCase();
+
+  // Guard: Only try derivation if text looks like a proof/derivation
+  const hasDerivationKeywords =
+    lower.includes("show") ||
+    lower.includes("prove") ||
+    lower.includes("verify") ||
+    lower.includes("derivation") ||
+    lower.includes("simplif") ||
+    lower.includes("therefore") ||
+    lower.includes("thus") ||
+    lower.includes("hence") ||
+    text.includes("⟹") ||
+    text.includes("→") ||
+    text.includes("=>") ||
+    // Multiple equals signs suggest a derivation chain
+    (text.match(/=/g)?.length ?? 0) >= 2;
+
+  if (!hasDerivationKeywords) {
+    return { solved: false, confidence: 0 };
+  }
+
+  const steps = extractDerivationSteps(text);
+
+  if (steps.length < 1) {
+    return { solved: false, confidence: 0 };
+  }
+
+  const result = verifyDerivationSteps(steps);
+  const time_ms = performance.now() - start;
+
+  if (result.valid) {
+    return {
+      solved: true,
+      result: `Valid derivation (${result.steps.length} steps verified)`,
+      method: "derivation_verification",
+      confidence: 1.0,
+      time_ms,
+    };
+  }
+
+  return {
+    solved: true,
+    result: result.error ?? "Invalid derivation",
+    method: "derivation_verification",
+    confidence: 0.9, // Slightly lower confidence for invalid results
+    time_ms,
+  };
+}
+
+/** Human-readable explanation of a derivation error */
+export interface DerivationErrorExplanation {
+  /** Short summary of the error */
+  summary: string;
+  /** Detailed explanation suitable for display */
+  explanation: string;
+  /** The problematic step (1-indexed) */
+  stepNumber: number;
+  /** What was expected */
+  expected?: string;
+  /** What was found */
+  found?: string;
+  /** Specific suggestions to fix the error */
+  fixSuggestions: string[];
+}
+
+/**
+ * Generate a human-readable explanation for a derivation verification error
+ *
+ * Analyzes the DerivationResult and produces clear, actionable feedback
+ * about what went wrong and how to fix it.
+ *
+ * @param result The DerivationResult from verifyDerivationSteps
+ * @returns DerivationErrorExplanation with detailed feedback, or null if valid
+ */
+export function explainDerivationError(
+  result: DerivationResult,
+): DerivationErrorExplanation | null {
+  // No error to explain if derivation is valid
+  if (result.valid) {
+    return null;
+  }
+
+  const invalidStep = result.invalidStep ?? 1;
+  const errorStep = result.steps.find((s) => !s.valid);
+
+  if (!errorStep) {
+    // Generic error (no steps found, etc.)
+    return {
+      summary: result.error ?? "Derivation verification failed",
+      explanation:
+        result.error ??
+        "The derivation could not be verified. Ensure each step follows logically from the previous.",
+      stepNumber: 0,
+      fixSuggestions: [
+        "Check that the derivation contains valid mathematical expressions",
+        "Ensure each line follows the format 'expression = expression'",
+        "Verify that equals signs (=) are used correctly",
+      ],
+    };
+  }
+
+  const { lhs, rhs, error } = errorStep;
+
+  // Determine error type and generate appropriate explanation
+  const isDiscontinuity = error?.includes("doesn't follow") || error?.includes("Discontinuity");
+
+  if (isDiscontinuity) {
+    // Continuity error: previous RHS doesn't match current LHS
+    return {
+      summary: `Derivation breaks at step ${invalidStep}`,
+      explanation:
+        `Step ${invalidStep} doesn't follow from the previous step. ` +
+        `The left side of step ${invalidStep} ('${lhs}') should equal the right side of step ${invalidStep - 1}. ` +
+        `Each step must connect to the previous step to form a valid chain.`,
+      stepNumber: invalidStep,
+      expected: `Continue from previous result`,
+      found: lhs,
+      fixSuggestions: [
+        `Ensure step ${invalidStep} starts with the result from step ${invalidStep - 1}`,
+        `Check for typos or missing intermediate steps`,
+        `If changing variables, show the substitution explicitly`,
+      ],
+    };
+  }
+
+  // Equivalence error: LHS and RHS of the same step are not equivalent
+  return {
+    summary: `Invalid algebraic transformation at step ${invalidStep}`,
+    explanation:
+      `The expression '${lhs}' is not algebraically equivalent to '${rhs}'. ` +
+      `This transformation cannot be justified by standard algebraic rules. ` +
+      `The two expressions evaluate to different values.`,
+    stepNumber: invalidStep,
+    expected: lhs,
+    found: rhs,
+    fixSuggestions: [
+      `Verify the algebraic manipulation from '${lhs}' to '${rhs}'`,
+      `Check for sign errors or incorrect coefficient handling`,
+      `Consider adding intermediate steps to make the transformation clearer`,
+      `If this is a substitution, ensure the substituted value is correct`,
+    ],
+  };
+}

package/src/lib/compute/solvers/derivation-latex.ts

@@ -0,0 +1,160 @@
+/**
+ * Derivation LaTeX - converts derivations to LaTeX format
+ *
+ * Produces LaTeX code suitable for mathematical documents with proper
+ * alignment of equals signs and optional step numbering.
+ *
+ * @module derivation-latex
+ */
+
+import { extractDerivationSteps } from "./derivation-core.ts";
+
+/** Options for LaTeX derivation formatting */
+export interface DerivationLatexOptions {
+  /** Use align environment for multi-step (default: true) */
+  useAlign?: boolean;
+  /** Add step numbers as comments (default: false) */
+  showStepNumbers?: boolean;
+  /** Include "therefore" symbol before final step (default: false) */
+  showTherefore?: boolean;
+  /** Custom label for the derivation (default: none) */
+  label?: string;
+}
+
+/**
+ * Convert an expression to LaTeX notation
+ */
+function toLatex(expr: string): string {
+  let result = expr;
+
+  // Convert multiplication: * or · → \cdot
+  result = result.replace(/\s*[*·×]\s*/g, " \\cdot ");
+
+  // Convert division: ÷ → \div (or could use \frac)
+  result = result.replace(/\s*÷\s*/g, " \\div ");
+
+  // Convert powers: x^2 → x^{2}, x^10 → x^{10}
+  result = result.replace(/\^(\d+)/g, "^{$1}");
+  result = result.replace(/\^([a-zA-Z])/g, "^{$1}");
+
+  // Convert sqrt: sqrt(x) → \sqrt{x}
+  result = result.replace(/sqrt\(([^)]+)\)/gi, "\\sqrt{$1}");
+
+  // Convert common functions
+  result = result.replace(/\b(sin|cos|tan|log|ln|exp)\b/g, "\\$1");
+
+  // Convert pi → \pi
+  result = result.replace(/\bpi\b/gi, "\\pi");
+
+  // Convert fractions: a/b → \frac{a}{b} (simple cases only)
+  result = result.replace(/(\d+)\s*\/\s*(\d+)/g, "\\frac{$1}{$2}");
+
+  // Handle minus signs for better rendering
+  result = result.replace(/−/g, "-");
+
+  return result;
+}
+
+/**
+ * Convert a derivation chain to LaTeX format with aligned equations
+ *
+ * Produces LaTeX code suitable for mathematical documents with proper
+ * alignment of equals signs and optional step numbering.
+ *
+ * @param steps Array of {lhs, rhs} pairs representing the derivation
+ * @param options Formatting options
+ * @returns LaTeX string
+ *
+ * @example
+ * derivationToLatex([
+ *   { lhs: "x + x", rhs: "2x" },
+ *   { lhs: "2x", rhs: "2 * x" }
+ * ])
+ * // Returns:
+ * // \begin{align}
+ * //   x + x &= 2x \\
+ * //   &= 2 \cdot x
+ * // \end{align}
+ */
+export function derivationToLatex(
+  steps: Array<{ lhs: string; rhs: string }>,
+  options: DerivationLatexOptions = {},
+): string {
+  const { useAlign = true, showStepNumbers = false, showTherefore = false, label } = options;
+
+  if (steps.length === 0) {
+    return "";
+  }
+
+  const lines: string[] = [];
+
+  if (useAlign) {
+    const envStart = label ? `\\begin{align}\\label{${label}}` : "\\begin{align}";
+    lines.push(envStart);
+
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      if (!step) continue;
+
+      const isFirst = i === 0;
+      const isLast = i === steps.length - 1;
+
+      const lhsLatex = toLatex(step.lhs);
+      const rhsLatex = toLatex(step.rhs);
+
+      let line: string;
+
+      if (isFirst) {
+        // First line shows full equation
+        line = `  ${lhsLatex} &= ${rhsLatex}`;
+      } else {
+        // Subsequent lines only show RHS (aligned at =)
+        if (showTherefore && isLast) {
+          line = `  &\\therefore ${rhsLatex}`;
+        } else {
+          line = `  &= ${rhsLatex}`;
+        }
+      }
+
+      // Add step number comment
+      if (showStepNumbers) {
+        line += ` && \\text{(${i + 1})}`;
+      }
+
+      // Add line continuation (except last line)
+      if (!isLast) {
+        line += " \\\\";
+      }
+
+      lines.push(line);
+    }
+
+    lines.push("\\end{align}");
+  } else {
+    // Simple equation environment (no alignment)
+    const allExprs = steps.map((s) => `${toLatex(s.lhs)} = ${toLatex(s.rhs)}`);
+    lines.push("\\begin{equation}");
+    lines.push(`  ${allExprs.join(" = ")}`);
+    lines.push("\\end{equation}");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Convert text containing a derivation to LaTeX
+ *
+ * @param text Text containing a derivation
+ * @param options Formatting options
+ * @returns LaTeX string or null if no derivation found
+ */
+export function derivationTextToLatex(
+  text: string,
+  options: DerivationLatexOptions = {},
+): string | null {
+  const steps = extractDerivationSteps(text);
+  if (steps.length === 0) {
+    return null;
+  }
+  return derivationToLatex(steps, options);
+}