Step Dependency Mapping and Validation Prompt

This prompt is built for debugging teams and evaluation engineers who need to verify that each step in a reasoning trace correctly depends on prior steps. The core job-to-be-done is dependency integrity checking: does step 4 actually follow from what was established in steps 1 through 3, or did the model make an unsupported leap? The ideal user is someone staring at a long chain-of-thought output and asking 'where did this conclusion come from?'—not someone grading the final answer for correctness. You need the full reasoning trace as input, and you should already suspect that the model is fabricating connections, ignoring earlier findings, or treating speculation as established fact.

Use this when you're debugging reasoning failures in production agents, auditing RAG pipelines for faithfulness, or building evaluation harnesses that need to catch structural reasoning errors before they reach users. The prompt produces a structured dependency graph with explicit link validation, broken-link detection, and severity ratings. Each dependency claim gets checked: does the referenced step actually contain the information the current step claims to inherit? When a link is broken, the output tells you whether the step fabricated a connection, contradicted prior steps, or silently dropped an established conclusion. This is particularly valuable for multi-step math solutions, legal analysis traces, medical reasoning workflows, and any domain where the path matters as much as the destination.

Do not use this prompt when you need a general correctness grader, a factual accuracy checker, or a logical validity assessor. It does not evaluate whether the reasoning is sound—only whether each step's claimed dependencies actually exist in the preceding steps. If you need to catch logical fallacies, use the Fallacy Detection in Chain-of-Thought Prompt. If you need to verify factual grounding against source documents, use the Factual Grounding Check Across Reasoning Steps Prompt. If you need to assess whether the conclusion follows from the reasoning, use the Conclusion-Support Alignment Scoring Prompt. This prompt answers one narrow question: does each step actually follow from what came before it?

The output is most useful when wired into an automated evaluation pipeline that flags broken dependencies before human review. Set severity thresholds based on your risk tolerance: a single broken link in a ten-step trace might be acceptable for low-stakes summarization, but any broken link in a medical or legal reasoning trace should trigger immediate human review. Pair this prompt with the Error Propagation Analysis in Reasoning Chains Prompt to trace how early dependency breaks cascade through later steps. For production systems, log the dependency graph alongside the original trace so you can track whether model updates reduce broken-link rates over time.

This prompt template is designed to be dropped directly into your evaluation harness for step dependency mapping and validation. It instructs the model to analyze a provided reasoning trace, identify explicit and implicit dependencies between steps, construct a dependency graph, and flag any broken links where a step references a conclusion or fact not yet established. The template uses square-bracket placeholders that you must replace with your specific reasoning trace, output schema, and operational constraints before execution.

textCopy
You are an expert reasoning auditor. Your task is to analyze the provided reasoning trace and produce a step dependency map.

## INPUT
[REASONING_TRACE]

## INSTRUCTIONS
1. Parse the reasoning trace into discrete, numbered steps. Each step should be a single logical unit.
2. For each step, identify its dependencies: what prior steps, facts, or assumptions must be true for this step to be valid? Distinguish between explicit dependencies (directly cited) and implicit dependencies (logically required but not stated).
3. Construct a dependency graph as a list of edges, where each edge is a directed link from a dependency source to the dependent step. Use step numbers as node identifiers.
4. Validate the graph by checking for broken links. A broken link occurs when a step depends on a conclusion, fact, or value that has not been established in any prior step or provided context.
5. For each broken link, provide a severity rating (CRITICAL, HIGH, MEDIUM, LOW) and a brief explanation of why the dependency is unsatisfied.

## OUTPUT_SCHEMA
[OUTPUT_SCHEMA]

## CONSTRAINTS
- Do not invent dependencies that are not present in the trace.
- If a step depends on common knowledge or an axiom stated in the prompt, note it as an external dependency, not a broken link.
- If the trace is too ambiguous to parse into steps, output a single error object explaining why.

## RISK_LEVEL
[RISK_LEVEL]

After pasting the template, replace [REASONING_TRACE] with the full text of the chain-of-thought output you are auditing. Replace [OUTPUT_SCHEMA] with your expected JSON structure—for example, an object containing steps, edges, and broken_links arrays. Set [RISK_LEVEL] to HIGH if this audit feeds into a safety-critical or compliance pipeline, which will instruct the model to adopt a stricter, more conservative stance on flagging potential issues. For high-risk workflows, always route outputs flagged with CRITICAL or HIGH severity broken links for human review before accepting the reasoning trace as valid. Before deploying, run this prompt against a golden dataset of reasoning traces with known dependency errors to calibrate your evaluation thresholds and confirm the model correctly identifies both obvious and subtle broken links.

The Step Dependency Mapping and Validation Prompt is designed to be integrated into an automated reasoning evaluation pipeline, not used as a one-off manual check. Its primary job is to receive a multi-step reasoning trace and return a structured dependency graph with explicit broken-link detection. The harness must supply the full reasoning trace as [REASONING_TRACE], an optional [CONTEXT] containing source documents or established facts, and a [DEPENDENCY_SCHEMA] that defines the expected output format. The prompt returns a JSON object mapping each step to its declared dependencies, validated dependencies, and any broken links where a step references a prior conclusion that was never established or was contradicted later.

Wire this prompt into your evaluation harness by calling it after the primary reasoning model produces its trace. Use a structured output API or a strict JSON mode to enforce the [DEPENDENCY_SCHEMA]. Implement a post-processing validator that checks: (1) every step ID in the dependency graph exists in the original trace, (2) every dependency reference points to a real prior step, and (3) broken-link flags include the specific step indices and the nature of the failure. For high-stakes debugging workflows, add a retry layer: if the prompt returns malformed JSON or missing step IDs, retry once with a simplified [REASONING_TRACE] truncated to the suspect region. Log every dependency graph alongside the original trace for later analysis. Model choice matters here—use a model with strong structured output capabilities and long-context handling, as reasoning traces can span thousands of tokens. For traces exceeding the model's context window, chunk the trace into overlapping segments and run dependency mapping per segment, then merge graphs with a reconciliation step that checks cross-segment references.

Avoid treating this prompt as a final verdict without human review when broken links are detected in safety-critical or regulated domains. A flagged dependency failure indicates the reasoning trace made an unsupported leap, but the root cause could be a poorly stated prior step, an implicit assumption the model didn't surface, or a genuine logical error. Use the output to route traces to a human review queue when broken-link severity exceeds a configurable threshold. Do not use this prompt to evaluate traces shorter than three steps—dependency mapping adds noise when there isn't enough structure to analyze. Pair this prompt with the Step-by-Step Correctness Grading Prompt and the Error Propagation Analysis in Reasoning Chains Prompt for a complete reasoning quality pipeline.