Principle:Diagram of thought Diagram of thought Iterative Propose and Critique

Overview

Iterative Propose and Critique is the core self-correction mechanism in Diagram of Thought (DoT) reasoning, in which a single model alternates between proposing atomic reasoning steps and critically evaluating them to incrementally construct a validated Directed Acyclic Graph (DAG) of reasoning.

Description

The propose-critique cycle is the central reasoning loop in the DoT framework. Within a single autoregressive language model, two internal roles take turns driving the reasoning process forward:

• The proposer role generates an atomic reasoning step -- a clear, concrete proposition that advances the solution. Each proposition builds upon previously validated nodes in the DAG, declaring its dependencies explicitly.
• The critic role evaluates the most recent proposition for logical consistency, factual accuracy, and soundness. The critic issues a judgment: either validated (the proposition is correct and may be used as a foundation for further reasoning) or invalidated (the proposition contains a flaw and must be revised).

This alternation enables self-correction within a single model, without requiring external controllers, multi-agent orchestration, or search algorithms. The model itself identifies errors and corrects course.

The DAG grows incrementally with each iteration of the loop. Every proposer step adds a new node to the graph, and every critic step adds an evaluation node linked to the proposition it assessed. The structure that emerges is not a linear chain but a directed acyclic graph that can branch when a proposition is invalidated and an alternative path is explored.

Validated nodes form the reliable foundation for further reasoning. Subsequent proposer steps may depend on any previously validated node, enabling the model to draw on multiple independent lines of verified evidence. Invalidated nodes, by contrast, trigger refinement branches: the proposer generates a new proposition that addresses the flaw identified by the critic, creating a "refine" edge in the DAG. The invalidated node is not discarded from the graph -- it remains as an auditable record of the reasoning process -- but it is excluded from the final synthesis.

This iterative cycle continues until the reasoning converges (i.e., sufficient validated evidence has been accumulated to answer the question), at which point a summarizer role synthesizes the final answer from validated nodes only.

Usage

Use the Iterative Propose and Critique principle for any reasoning task that benefits from verification and self-correction, including:

• Mathematical and logical problem-solving where each step must be verified before proceeding.
• Factual reasoning where claims need to be checked for accuracy.
• Multi-step analysis where errors in early steps compound if left uncorrected.
• Tasks requiring exploration where the first approach may not be optimal and the model must consider alternatives.

This principle is applicable whenever a single model must produce reliable, auditable reasoning without relying on external verification systems.

Theoretical Basis

The Iterative Propose and Critique loop is grounded in the paper's category-theoretic formalization of reasoning:

• Propositions as subobjects: Each validated proposition is interpreted as a subobject in a slice topos -- a formal mathematical space that captures the information content of a reasoning step relative to the problem context.
• Critiques as morphisms: The critic's evaluation acts as a morphism (structure-preserving map) between the proposition and the space of logical judgments. A critique examines whether a proposition is consistent with the established reasoning context.
• Validation as a logical judgment: The validated or invalidated mark corresponds to a truth-value assignment in the internal logic of the topos. Validated propositions are "true" relative to the current reasoning state; invalidated propositions are "false" and require refinement.
• Acyclicity constraint (src < dst): The DAG's structural constraint -- that every edge must point from a lower-numbered node to a higher-numbered node -- ensures forward progress. The reasoning process cannot loop back on itself or create circular dependencies. Each new node strictly extends the graph, guaranteeing termination and well-foundedness.

The abstract loop can be expressed in pseudo-code as follows:

while not converged:
    proposition = proposer(context)
    judgment = critic(proposition)
    if judgment == invalidated:
        context.branch(refine)
    else:
        context.extend(validated)

When the loop terminates, the final synthesis (performed by the summarizer) corresponds to a colimit in the information order -- a universal construction that optimally aggregates all validated evidence into a single coherent answer, invariant to the order in which that evidence was explored.

Related Pages

• Implementation:Diagram_of_thought_Diagram_of_thought_Proposer_Critic_XML_Cycle -- Concrete implementation pattern using XML tags and typed serialization records.