Abstract What n+1 Rationale sets out to do

n+1 Rationale is a method for making the reasoning between statements explicit. It examines each adjacent pair of statements and asks what necessary intermediate statement connects them. The paper calls that connecting statement a bridge, or interpolant.

Start with a chain of n statements that are claimed to follow logically from one another. The method inserts the required bridge between each pair, renumbers the expanded chain, and repeats when requested. It continues until the transitions are atomic—reduced to individual inference steps—or it detects a break. If no valid bridge exists, it stops moving forward and works backward to locate the faulty premise. In this way, the method is also intended to expose where an argument fails.

The paper connects this process to five mathematical foundations. These address how valid steps can be linked, how hidden proof steps become explicit, how a chain becomes more complete, when the process stops, and how reasoning relates to computer programs.

The paper also develops the computational cost of each pass, presents termination proofs for decidable logics, establishes a logarithmic account of convergence for the largest reasoning gap, and examines connections to resolution-based theorem proving and proof nets. These claims and their conditions are set out in the sections that follow.

Finally, it specifies n+1 Rationale as an integrable skill for large language models and systems of multiple AI agents. A formal tool schema makes the method callable as an operator. An agent architecture that produces or receives structured arguments can use it to check reasoning, support a self-correction loop, or make a reasoning chain more explicit.

01 Why reasonable statements can still form a weak argument

1.1 The missing reasoning between steps

An argument is a chain of claims. For the argument to work, it is not enough for each claim to sound plausible. Each transition must be necessary: the next statement must be forced by what has already been established.

In everyday reasoning, people and language models often leave something out. Step k + 1 may require an unstated assumption, an unmentioned premise, or a background fact that the writer takes for granted. The paper identifies these hidden leaps as the main source of logical error. They are hard to detect by reading for surface plausibility because each statement can look reasonable on its own.

The usual response is peer review: another person reads the argument and points out gaps. That takes time and money, depends on the reviewer’s judgment, and is difficult to scale. It also asks the reviewer to notice information that is missing. The paper describes that task as the hardest kind of cognitive evaluation.

1.2 Why fluent AI writing makes the problem harder

The paper identifies two ways that large language models amplify this problem:

1. Fluent writing can conceal a gap. A model can produce grammatically polished and persuasive text that sounds like reasoning. That fluency can make a missing connection harder for the reader to notice.
2. Showing steps does not verify them. Chain-of-thought prompting [Wei et al., 2022] and tree-of-thought methods [Yao et al., 2023] improve model reasoning, but do not themselves check that each transition follows. They encourage a model to show its work without enforcing the logical connection between the steps it shows.

1.3 What n+1 Rationale asks at every gap

n+1 Rationale turns the review into a local, mechanical question: for every adjacent pair of steps, derive the necessary bridge or declare the chain broken. The criterion is not a score, a preference, or a rule of thumb. At each gap, it asks whether a forced interpolant exists.

• Iterative. Each pass applies the paper’s step-doubling rule. Repeated passes make the transitions finer until they are atomic; §2 gives the exact step counts.
• Conservative. It inserts bridges. It does not alter existing steps without explicit approval.
• Falsifiable. If a bridge cannot be derived, it stops and follows the fault backward through the chain.
• Composable. The operator is intended to apply to any sequential argument, in any domain.

1.4 How the paper proceeds

Section 2 defines the method. Section 3 introduces its five mathematical foundations. Section 4 develops the computational model, complexity bounds, and termination proofs. Section 5 formalizes break detection, and section 6 addresses convergence. Section 7 specifies how the method integrates with language models and multiple agents. Section 8 covers applications; section 9 covers limitations and open questions. Section 10 examines related work in more detail, and section 11 concludes.

02 The parts of a reasoning chain

The framework is intended to cover formal logic—propositional, first-order, and higher-order—as well as partly formal arguments written in everyday language and processed by an LLM oracle. An oracle is the component asked to answer a logical question. Where a result needs a particular logic or property, the paper states that requirement.

2.1 Statements, starting points, and valid transitions

Definition 2.1 — Language. Begin with a logical language ℒ: a set of rules for writing statements. Wff(ℒ) is the set of statements that are correctly formed in that language. The symbol ⊨_ℒ, shortened to ⊨ when the language is clear, means “logically implies.” The paper requires three properties:

• Reflexivity: a statement follows from itself.
• Monotonicity: adding premises does not remove a conclusion that already follows.
• Transitivity, also called Cut: if the premises establish an intermediate statement, and those premises together with that statement establish a conclusion, the original premises already establish that conclusion.

Definition 2.2 — Argument chain. An argument chain is a finite, ordered sequence of statements:

The first statement, p₀, is the premise (START): the starting assumption. The last, p_n, is the conclusion (END): the claimed result. Each statement between them, p_i for 0 < i < n, is an intermediate anchor. The chain claims that the conclusion follows from the premise through these intermediate statements.

The context at a position includes every statement from the start up to that position. It is written Γ(i).

Definition 2.3 — Transition validity. A move from one statement to the next is valid when the next statement is a logical consequence of the entire accumulated context.

Definition 2.4 — Chain soundness. The paper calls a chain sound when every transition, for 0 ≤ i < n, is valid. One or more invalid transitions means the chain contains a break.

Remark 2.1. A transition does not have to follow from the immediately preceding statement alone. It must follow from the cumulative context Γ(i). Proofs regularly need premises established several steps earlier, and this definition keeps those premises available.

Definition 2.5 — Chain strength. The paper gives each transition a strength value. A value of 1 means the next statement is, up to logical equivalence, the unique simplest consequence of the current context that entails that statement. A value of 0 means the transition is valid but has multiple independent paths. A value of −1 means the next statement does not follow from the context.

A chain is maximally tight when every value is 1. It is broken if any value is −1. The remaining chains are valid but loose; these are the chains densification targets.

2.2 What counts as a bridge

Definition 2.6 — Bridge. For a valid transition in a sound chain, a bridge q_i is a correctly formed statement that meets four conditions:

1. It follows from the existing context. The statements already in the chain must establish the bridge: Γ(i) ⊨ q_i.
2. The context plus the bridge establishes the next statement. Formally, Γ(i) ∪ {q_i} ⊨ p_i+1.
3. Its vocabulary is shared by the two adjacent statements. The bridge’s non-logical symbols must occur in both p_i and p_i+1.
4. It is no stronger than necessary. No weaker bridge may satisfy the first three conditions while being implied by this bridge without also implying it back.

Remark 2.2. The paper identifies condition 3 with Craig’s vocabulary restriction. It describes condition 4 as selecting the logically weakest interpolant: a bridge that commits to nothing more than the transition requires. The stated purpose is to prevent information from leaking across the chain.

Definition 2.7 — Trivial bridge. A bridge is trivial if it is logically equivalent to either adjacent statement. It adds no new information. Under this definition, the transition is already atomic.

2.3 One pass: insert bridges and renumber

Definition 2.8 — Densification operator. The operator 𝒟 carries out one pass. It inserts a bridge between every adjacent pair and renumbers the resulting sequence with whole-number indices. It is a partial function: it does not return an expanded chain for every possible input.

If any transition lacks a valid bridge, the operator is undefined, written 𝒟(C) = ⊥. The paper identifies this case with a chain that is not sound.

Theorem 2.1 — Step doubling. A chain with n + 1 statements, numbered 0 through n, becomes a chain with 2n + 1 statements after one pass.

2.4 Repeating the pass

Definition 2.9 — k-fold densification. Zero passes leaves the chain as it is. Each additional pass applies the same operator to the result of the previous pass.

Theorem 2.2 — Growth rate. If the starting chain has n + 1 statements, then after k passes it has:

Corollary 2.3 — Dyadic positions. After k passes, each original interval from i to i + 1 contains 2^k + 1 points at positions i + j/2^k, for j ∈ {0, 1, …, 2^k}. Fractions with powers of two in the denominator are called dyadic rationals. Taken together, these fractions are dense in the real numbers: any two distinct real numbers have a dyadic rational between them.

03 The five mathematical foundations

3.1 Craig’s interpolation: the mathematical account of a bridge

Theorem 3.1 — Craig, 1957. In a first-order language, suppose statement A logically implies statement B, and A is satisfiable. The theorem gives an intermediate formula I, called an interpolant, that follows from A, implies B, and uses only non-logical symbols shared by A and B.

Theorem 3.2 — Bridge existence. The paper argues that, for a sound chain in a first-order language with the interpolation property, every valid transition has a bridge meeting all four conditions in Definition 2.6.

Theorem 3.3 — No bridge means an invalid transition. In a logic with the interpolation property, the paper concludes that if no bridge exists for p_i → p_i+1, the accumulated context does not imply the next statement: Γ(i) ⊭ p_i+1. Its proof is the contrapositive of Theorem 3.2.

Remark 3.1 — Which logics have this property? The paper lists classical propositional logic, classical first-order logic, intuitionistic propositional logic [Schütte, 1962], and many modal logics, including K, S4, and GL [Maksimova, 1979]. It also lists common temporal logics LTL and CTL under appropriate formulations.

It says interpolation fails in some first-order fragments, such as the two-variable fragment without equality [Marx, 2007], in certain description logics, and in most non-monotonic logics. The scope of n+1 Rationale is therefore bounded by whether the chosen logic has the interpolation property.

3.2 Gentzen’s cut elimination: making intermediate proof work explicit

Theorem 3.4 — Gentzen, 1935. In the LK proof system for classical logic, or the LJ proof system for intuitionistic logic, any proof using the cut rule can be transformed into one that does not use it.

The cut rule allows a proof to bring in an intermediate result, or lemma. If one set of premises proves A, and A together with another set proves B, the two sets of premises establish B.

The paper describes a proof with cuts as being able to invoke the lemma A without displaying its intermediate derivation at that point. It describes a cut-free proof as one in which every intermediate step is explicit.

Theorem 3.5 — Densification as operational cut elimination. Consider a sound argument chain and an LK proof of its conclusion from its starting premise. If that proof uses k cuts at positions corresponding to the chain’s transitions, the paper argues that one densification pass corresponds to a proof with at most k cuts, each with a smaller cut-rank.

Corollary 3.6. The paper concludes that a fixed point of 𝒟 corresponds to a cut-free proof: every transition applies an introduction rule or a structural rule, with no implicit lemmas. A fixed point is defined in §3.4 below.

3.3 Completeness and order: measuring the remaining reasoning gaps

Definition 3.1 — Logical chain order. The paper orders positions using both their sequence and their logical support. It writes p_i ≼ p_j when i ≤ j and the context at position i implies p_j. It calls this a partial order on formulas; for a sound chain, it describes the relation as a total preorder on chain positions.

Definition 3.2 — Inferential distance. The distance between adjacent statements is the smallest number of individual inference-rule applications needed to derive the next statement from the current one, with the accumulated context available.

Remark 3.4 — Where the distance measure matters. The earlier framework in §§2–3.1 asks a yes-or-no question: does the accumulated context imply the next statement? The basic densification operator in Definition 2.8 and the break-detection results in Theorems 3.2–3.3 do not require a numerical measure of how far apart the statements are.

Distance becomes necessary when asking how many passes are needed to reach atomic steps. The convergence results in §6 depend on this measure and on an extra requirement: the oracle must be able to choose bridges that approximately halve the inferential distance. That is a stronger requirement than the basic oracle specification in §4.1. It is formalized in Definition 4.7, in §4.6.

Proposition 3.7 — An analogy with Dedekind completion. Consider the chain and each increasingly refined version:

The paper argues that, in the idealized case of a decidable logic with only finitely many expressible intermediate formulas, this sequence converges to a complete chain C*. Every remaining adjacent gap then has distance 1: d_C*(i, i+1) = 1 for all i. The paper compares this with Dedekind completion of the rational numbers ℚ to the real numbers ℝ: every “cut” in the inferential order has been filled.

Remark 3.2 — The dyadic structure. The renumbering scheme places refinements at fractions whose denominators are powers of two. After k passes, the points inside each original interval [i, i+1] are:

3.4 Fixed points: when another pass adds nothing new

Definition 3.3 — Chain lattice. Take the collection 𝒞_ℒ of all finite sound chains in the chosen language. Order them by refinement: C₁ ⊑ C₂ means that C₂ can be obtained from C₁ by inserting intermediate formulas, without changing the original formulas or their order. This gives a partially ordered set (𝒞_ℒ, ⊑).

Proposition 3.8 — Monotonicity of 𝒟. The paper argues that the densification operator preserves this refinement ordering. If one chain refines another, applying the operator to both preserves that relationship, provided both applications are defined.

Definition 3.4 — Fixed point. A chain has reached a fixed point when every bridge another pass would insert is trivial: it is logically equivalent to an adjacent step. The pass therefore adds no new logical content.

Theorem 3.9 — Fixed-point existence, using Knaster–Tarski. If the ordered collection of chains is a complete lattice, the paper states that 𝒟 has a least fixed point. The source says the complete-lattice condition holds when the language is finite or decidable, bounding the intermediate formulas that can be expressed.

Corollary 3.10 — Uniqueness of atomic refinement. Under the conditions of Theorem 3.9, the paper identifies μ𝒟 as the unique coarsest chain in which every transition is atomic.

3.5 Curry–Howard: relating explicit reasoning to typed programs

Theorem 3.11 — Curry–Howard correspondence. The theorem describes a structural relationship between proofs and programs:

• Proofs in intuitionistic natural deduction correspond to terms in simply typed λ-calculus.
• Propositions correspond to types.
• Proof normalization, or cut elimination, corresponds to β-reduction.

Connection to n+1 Rationale. Under this correspondence, the chain C = ⟨p₀, …, p_n⟩ maps to a sequence of typed terms:

Each next term is built from earlier terms using function application, abstraction, or other term constructors. The paper compares a hidden leap with an implicit coercion: using a term of type p_i as though it had another type, without an explicit witness that supports the conversion.

Proposition 3.12 — Bridges as type witnesses. The paper argues that a bridge q_i corresponds to an explicit term w_i : q_i that witnesses the conversion. A fully densified chain therefore corresponds to a fully elaborated term, with explicit witnesses in place of all implicit coercions.

Remark 3.3 — Computational content. From this perspective, a densified chain is more than a list of claims: it is a program that constructs the conclusion from the premise, with each bridge serving as a computation step. The paper presents a potential use in formal verification: in principle, a densified chain could be compiled into a proof term and checked by a type-checker.

04 How the method runs

4.1 Turning the method into a procedure

Algorithm 1: DENSIFY. Start with a list of claims. For each neighboring pair, keep the first claim, gather every claim in the input chain up to that point, and ask a bridge-finding service—called the oracle—for the missing connection. Add that connection after the claim. If the oracle returns BREAK, stop this pass and trace backward to report the fault. Otherwise, finish with the original conclusion and number the expanded list again.

Input:  chain C = ⟨p₀, p₁, ..., pₙ⟩, oracle O : (Γ, A, B) → Wff(L) ∪ {BREAK}
Output: D(C) or BreakReport

1.  new ← empty list
2.  for i ← 0 to n-1:
3.      new.append(pᵢ)
4.      Γ ← {p₀, ..., pᵢ}
5.      q ← O(Γ, pᵢ, pᵢ₊₁)           // Query oracle for interpolant
6.      if q = BREAK:
7.          fault ← TRACE_UPSTREAM(C, i)
8.          return BreakReport(i, i+1, fault)
9.      new.append(q)
10. new.append(pₙ)
11. return REINDEX(new)                 // Relabel 0, 1, ..., 2n

Algorithm 2: TRACE_UPSTREAM. Starting at the break, work backward through the claims. At each position, ask whether that claim follows from everything before it. Return the first failure found in this backward search as a non-sequitur: a claim that does not follow. If all those checks pass but the original transition still breaks, report an unstated assumption—a missing premise.

Input:  chain C = ⟨p₀, ..., pₙ⟩, break index i
Output: FaultReport

1.  for j ← i downto 0:
2.      Γ ← {p₀, ..., p_{j-1}}
3.      if Γ ⊭ pⱼ:                     // Step j doesn't follow from its predecessors
4.          return FaultReport(step=j, type="non-sequitur")
5.  // All individual steps check out, but the transition i→i+1 still breaks
6.  return FaultReport(step=i, type="missing premise",
7.                     detail="Transition requires unstated assumption")

Remark 4.1 · What the oracle does. The oracle is the component that finds bridges. In formal logic, it can be a Craig interpolation procedure, such as Maehara’s method applied to a sequent-calculus proof. In a language-model system, it can be a model given instructions to find the connection. The surrounding procedure stays the same; the reliability of its bridge-finding component changes.

4.2 How much work each pass requires

Theorem 4.1 · Work per pass. For a chain containing m claims, the paper gives the following costs. Here, a token is a unit of text processed by a model. The notation O(…) describes how a cost grows as the input grows; it is not an exact token count.

1. Bridge requests: m − 1, because every neighboring pair needs one request.
2. Earlier context sent with each request: request i receives Γ(i), growing as O(i) tokens. Across all requests, the total grows as O(m²).
3. Generated text: O(m), with one bridge per pair.
4. Total text-processing cost: O(m²) per pass, because repeatedly supplying the earlier context dominates the cost.

Corollary 4.2 · Cost across repeated passes. Starting with n + 1 claims, the chain has n · 2^k−1 + 1 claims just before pass k. As the chain expands, the final pass dominates the combined cost.

Remark 4.2 · The paper’s practical examples. With n = 5—a starting outline of six claims—three passes produce 41 claims. The paper illustrates the cost as O(5² · 64) = O(1600) context-token units and describes this as comfortably within one model session. At five passes, the chain has 161 claims; its example is O(25 · 1024) ≈ O(25,000), which it also describes as feasible. The paper considers more than seven passes prohibitively costly for a language-model oracle. These are the paper’s scale estimates.

4.3 When the process stops

Theorem 4.3 · Finite propositional logic. Propositional logic works with statements that can be true or false. With v variables, there are at most 2^2v different truth functions—different ways a formula can behave across every possible assignment of truth values. The paper argues that repeated densification therefore ends within 2^2v passes.

Theorem 4.4 · Decidable first-order theories. A theory is decidable when a procedure can always settle the relevant logical question. Let T be a decidable first-order theory with the interpolation property. If every particular implication A ⊨_T B has only finitely many interpolants, counting logically equivalent formulas as the same, the paper argues that repeated densification ends.

Remark 4.3 · Everyday language. For arguments written in ordinary language and processed by a model, stopping is a practical judgment rather than a formal guarantee. The system treats bridges that merely restate their neighbors as a stopping signal, using a chosen semantic-similarity threshold to detect this repetition.

4.4 How it relates to other proof methods

The methods below approach a proof from different directions. Complete means a method can find every result covered by its stated scope. First-order logic, abbreviated FOL, describes objects, their properties, and their relationships.

Theorem 4.5 · The oracle determines the guarantee. With a complete interpolation oracle—one that finds a bridge whenever one exists—the paper states that break detection is sound and complete: every reported break is invalid, and every invalid transition is reported. In symbols, a break at p_i → p_i+1 is reported if and only if Γ(i) ⊭ p_i+1.

4.5 How it relates to dependency graphs

Definition 4.1 · Proof net [Girard, 1987]. In linear logic, a proof net is a graph showing a proof’s dependencies while leaving out differences in rule order that do not matter. Two sequent-calculus proofs that differ only in the ordering of their rules map to the same proof net.

Proposition 4.6 · Reading the graph as a chain. The paper argues that a fully densified, sound chain C* corresponds to a sequentialized proof net: its nodes are placed in a line that respects every dependency. Different valid orderings of the same net produce different chains, but the paper states that their step counts and bridges are the same, allowing for logical equivalence and reordering.

4.6 What is needed to shrink the gaps predictably

Sections 2–4.5 answer questions about whether bridges exist, how many claims a pass creates, and whether break detection is sound and complete. They do not measure the distance between claims. Section 6 asks a further question: how quickly does the largest remaining gap shrink? Answering that requires an additional assumption.

Remark 4.4 · The basic oracle requirement. Given the accumulated context Γ(i), the current claim p_i, and the next claim p_i+1, return some bridge q_i that meets Definition 2.6, or return BREAK if none exists.

The paper states that this basic requirement is sufficient for the results in Sections 2–5: bridge existence, step doubling, termination, break detection, and finding the source of a fault. It does not choose between several valid bridges.

Definition 4.7 · The optimal oracle. Here, inferential distance means the minimum number of single-rule inference steps needed to get from one claim to the next, using the available context. For every valid transition with distance d, an optimal oracle O* chooses the valid bridge that makes the larger of the two resulting distances as small as possible. In the paper’s description, it divides the derivation as evenly as possible.

Proposition 4.7 · The halfway bound. For an optimal oracle and a transition with distance d, the paper argues that neither resulting distance is greater than half of d, rounded up.

Remark 4.5 · This is an extra requirement. Theorem 6.1 and Corollary 6.2 require an optimal oracle. Finding any bridge that meets four conditions is a satisfiability task: find a qualifying answer. Finding the qualifying bridge that best divides the inferential distance is an optimization task: select the best answer under a specific measure.

For formal logics with constructive interpolation, such as Maehara’s method on sequent-calculus proofs, the paper says optimal selection can be achieved by choosing the proof tree’s midpoint. For language models working on ordinary text, this is only a heuristic. The prompt asks for the “narrowest mechanism that forces the next step.” The paper describes this as a practical proxy for minimality that empirically approximates an even split, with no formal guarantee.

Remark 4.6 · When selection is less than optimal. The paper states that convergence still occurs more slowly, as described in Proposition 6.3 under its progress condition. Choosing the optimal bridge changes the rate of convergence; it does not change the qualitative results about bridge existence, break detection, soundness, or completeness under their stated conditions.

05 Finding where an argument breaks

5.1 Test an argument by trying to find a failure

Karl Popper’s approach to science says theories cannot be finally verified; they can be falsified by a result that shows them to be wrong. A scientific theory must be open to such a test. Surviving attempts to refute it adds credibility.

Principle · Densification as an attempt to falsify. n+1 Rationale applies a parallel idea to an argument. A chain earns credibility by surviving checks of its connections. A valid bridge means that transition has survived an attempt to find a break. The paper treats each detected break as a genuine falsification of the claimed connection.

The paper presents this as a structural parallel, with these corresponding parts:

5.2 The different kinds of breaks

Definition 5.1 · Break classification. The paper classifies a break at p_i → p_i+1 by the kind of failure the oracle identifies. Γ(i) means every claim available up to position i; α names an additional assumption.

Proposition 5.1 · Classifying a propositional-logic break. For propositional logic, the paper states that the break type can be decided in the complexity class co-NP, a formal classification of computational difficulty. Its checks are: determine whether the context implies the opposite claim for a contradiction; check that it implies neither the claim nor its opposite for a non-sequitur; or search for a minimal added assumption α for a missing premise.

5.3 Work backward to locate the source

Definition 5.2 · Dependency set. A claim’s dependency set contains the earlier claims whose removal would stop it from following. To test whether p_i is such a dependency of p_j, remove p_i from the context immediately before p_j and check the implication again.

Theorem 5.2 · Locating the fault. When a break is detected between p_i and p_i+1, the paper places its source in one of three locations:

1. The next claim itself, p_i+1. It asserts something the chain cannot support.
2. A dependency used by the next claim but outside the dependency chain leading to the current claim. Formally, the paper writes p_j ∈ Dep(i+1) ∖ Dep(i). It treats this as a smuggled cross-reference.
3. An earlier claim p_j, where j ≤ i. Its actual wording supports less than later claims assume.

06 How quickly the remaining gaps shrink

6.1 Measuring the largest unfinished connection

Definition 6.1 · Maximum gap. Measure each neighboring transition by the smallest number of single-rule inference steps needed to derive it, as defined in Definition 3.2. The chain’s maximum gap is the largest of those distances.

Definition 6.2 · Comparing chains by their gaps. For chains with the same starting premise and final conclusion, the paper defines ρ as the absolute difference between their maximum gaps. It calls the resulting space of sound chains a metric space, stating that this follows because ρ comes from a real-valued function.

6.2 The paper’s main rate-of-progress result

Theorem 6.1 · Logarithmic convergence. Let a sound chain’s largest gap be d. If the oracle always chooses an optimal bridge—the valid bridge that minimizes the larger resulting sub-distance—the paper argues that one pass reduces the largest gap to no more than d/2, rounded up.

On that basis, after ⌈log₂ d⌉ passes, every remaining gap has distance 1: a single inference step. Here, log₂ describes the number of repeated halvings needed; the ceiling brackets ⌈…⌉ round that number up to a whole pass.

Corollary 6.2 · Size of the completed chain. With a starting chain of n + 1 claims, reaching gap = 1 after k = ⌈log₂ d⌉ passes gives this bound on its final size:

Remark 6.1 · Why the paper calls this bound tight. The paper states that a chain of n steps, with inferential distance exactly d in every gap, needs exactly nd atomic steps in any complete derivation. It therefore calls O(nd) a tight bound: the stated growth rate cannot be reduced in that case.

6.3 When the oracle cannot find the best split

Proposition 6.3 · Slower convergence. Suppose a less-than-optimal oracle still splits every gap of distance d′ into parts no larger than d′ − 1. Each bridge therefore removes at least one inference step from the larger unfinished part. Under this condition, the paper guarantees convergence, although it may take a number of passes proportional to the original distance rather than to its logarithm.

The stated worst case is d − 1 passes to reach single-inference transitions.

07 How n+1 Rationale can work with an AI assistant

7.1 The operations an application can call

The paper specifies n+1 Rationale as a stateless callable operator: a tool that an application can ask to do a job, with everything it needs included in that request. It defines three ways to call the tool.

Each request stands on its own. The tool receives the whole chain and returns its result. It does not need to remember an earlier conversation or request. The paper explains that this allows independent requests to run in parallel, results to be saved for reuse, and the tool to be combined with other tools.

7.2 Four ways to connect it to a workflow

Pattern 1: Check a draft after it is written

A user asks a question. A language model writes a draft chain of reasoning. n+1 Rationale checks that draft and returns either a chain with its connecting steps made explicit or a report identifying a break.

If the chain is sound, the workflow sends it to the user. If a break is found, the draft is revised and checked again.

Pattern 2: Check the model’s steps as it writes

In this pattern, the language model applies n+1 Rationale to its own chain of reasoning during generation. The paper calls this verified chain-of-thought (VCoT): the chain is checked before it is extended.

1. Generate steps 0–3.
2. Pause and run validate(steps 0–3).
3. If those steps are valid, continue with steps 4–6.
4. If the move from step 2 to step 3 breaks, revise step 3 before continuing.

Pattern 3: Give checking to a separate agent

In a system with several AI agents, one agent proposes the chain, n+1 Rationale acts as the critic, and another agent resolves the problems it finds. The critic’s role is to evaluate the connections between steps; it does not generate the proposed content.

The proposer sends its chain to the critic. If the critic finds a break, it sends that finding to the resolver. The resolver returns a revised step to the critic for checking.

The paper argues that separating these roles prevents the confirmation-bias failure mode in which the same model both creates and judges its own reasoning.

Pattern 4: Add detail in successive passes

The same chain can be expanded repeatedly so different readers can choose the depth they need. The paper illustrates this with a chain that starts with five steps.

Here, n is the number of gaps in the starting chain. Each full pass doubles the resolution of those gaps. Readers and reviewers choose how much detail to examine.

7.3 The tool’s input and output format

The proposed JSON schema is a structured description that tells another application what to send to the tool and what it can receive in return.

A request names the operation and supplies the ordered chain. Each step has an index and its full claim; it can also have a short title and a marker identifying it as an original step or a derived bridge. A request can specify the break position to trace, the number of densification passes, and the background rules the reasoning is allowed to use.

The result is classified as an expanded chain, a break report, or a validation result. The format also allows the tool to return the chain, a break’s position and type, the earlier faulty step, an explanation, the step count, the pass number, and an estimate of the largest reasoning gap still present.

{
  "name": "n_plus_1_rationale",
  "version": "2.0",
  "description": "Iterative logical densification operator. Audits argument chains for hidden leaps, derives necessary bridges (Craig interpolants), and detects breaks with upstream fault localization.",
  "parameters": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": ["densify", "validate", "trace"],
        "description": "The operation to perform."
      },
      "chain": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "step": { "type": "integer", "description": "Step index (0-based)" },
            "title": { "type": "string", "description": "Short forced-claim label" },
            "content": { "type": "string", "description": "Full proposition text" },
            "is_original": { "type": "boolean", "description": "True if from original chain, false if derived bridge" }
          },
          "required": ["step", "content"]
        },
        "description": "The argument chain as an ordered list of steps."
      },
      "break_index": {
        "type": "integer",
        "description": "For 'trace' action: the step index where the break was detected."
      },
      "pass_count": {
        "type": "integer",
        "default": 1,
        "description": "Number of densification passes to run (for 'densify' action)."
      },
      "axiom_set": {
        "type": "array",
        "items": { "type": "string" },
        "description": "Optional: domain-specific axioms the chain may rely on. Unstated axioms will be flagged as breaks.",
        "default": []
      }
    },
    "required": ["action", "chain"]
  },
  "returns": {
    "type": "object",
    "properties": {
      "result_type": {
        "type": "string",
        "enum": ["densified_chain", "break_report", "validation_result"]
      },
      "chain": {
        "type": "array",
        "description": "The resulting chain (for densify/validate)."
      },
      "break_report": {
        "type": "object",
        "properties": {
          "break_index": { "type": "integer" },
          "break_type": { "type": "string", "enum": ["missing_premise", "smuggled_premise", "contradiction", "non_sequitur", "granularity_gap"] },
          "upstream_fault": { "type": "integer", "description": "Index of the upstream step identified as faulty" },
          "explanation": { "type": "string" }
        }
      },
      "step_count": { "type": "integer" },
      "pass_number": { "type": "integer" },
      "max_gap_estimate": { "type": "number", "description": "Estimated maximum inferential gap remaining" }
    }
  }
}

7.4 Instructions for the AI that finds a bridge

An interpolation oracle is the component asked to find the necessary connecting claim between two steps, or to say that no such connection exists. When a language model fills that role, the paper proposes giving it a carefully structured prompt.

The prompt supplies all premises up to the current step, the current and next claims, and any declared background rules. It asks for a proposition Q that follows from the existing context and, together with that context, leads to the next step. The bridge must use only concepts shared by the two steps and be the weakest, most general proposition meeting those conditions.

The proposed instructions require one proposition, forbid simply repeating either endpoint, and exclude hedging or new concepts, entities, and facts. If no necessary bridge makes the next step follow, the response must begin with BREAK: and explain why in one sentence.

SYSTEM: You are a logical interpolation oracle implementing Craig's
Interpolation Theorem. You derive the necessary bridge between two
propositions, or declare that no bridge exists.

CONTEXT (cumulative premises through step {i}):
{steps_0_through_i}

CURRENT STEP (step {i}):
{step_i_content}

NEXT STEP (step {i+1}):
{step_i_plus_1_content}

AXIOM SET (background theory, if any):
{axiom_set}

TASK: Derive the proposition Q such that:
  1. The context through step {i} entails Q.
  2. The context through step {i} plus Q entails step {i+1}.
  3. Q uses only concepts present in both step {i} and step {i+1}.
  4. Q is the weakest (most general) such proposition.

CONSTRAINTS:
- Q must be a single proposition, not a conjunction of multiple claims.
- Q must not restate step {i} or step {i+1}.
- Q must not hedge: no "might", "could", "perhaps", "it is possible".
- Q must not introduce any concept, entity, or fact not present in the context.
- If no such Q exists — if step {i+1} does not follow from the context by
  any necessary bridge — respond exactly:
  BREAK: [one sentence explaining why no bridge exists]

08 Where the method could be useful

8.1 Checking an argument

The paper proposes using n+1 Rationale to examine the logic of a legal brief, scientific paper, policy proposal, business case, or another structured argument.

The input is the argument divided into numbered claims. The output is either an expanded chain that exposes its hidden assumptions or a report showing where the argument breaks. The aim is to reveal the actual logical structure beneath persuasive wording.

8.2 Checking reasoning produced by an AI

Applied to a language model’s chain of reasoning, the proposed method looks for steps that sound believable but do not follow from what came before. It also identifies places where the model has introduced knowledge that was not present in the prompt.

A structured error report can guide an automatic retry or correction. The paper also proposes a measurement called the break rate: the fraction of connections flagged as breaks across a set of test cases. It argues that this gives a more detailed view of reasoning quality than judging only whether the final answer is correct or incorrect.

8.3 Making a difficult explanation easier to follow

A learner can examine the same proof or argument at different levels of detail. In the paper’s example, pass 0 is the outline an expert might use; pass 3 and later provide the fully explicit derivation intended for beginners.

Students choose the amount of explanation they need. The break mechanism also supports critical reading by showing the exact point where an argument fails.

8.4 Reasoning with other people or agents

When several people or AI agents contribute different steps, the paper proposes checking that the combined chain stays sound as it grows. A detected break shows where contributors may be relying on different assumptions.

The dependency set in Definition 5.2 identifies which earlier steps a conclusion actually relies on. Making those dependencies visible can help contributors understand what they must agree on to reach a shared conclusion.

8.5 Following a requirement through to implementation

In software engineering and systems design, a chain often moves from a need to a feature, then to a specification, and finally to an implementation. The paper observes that these moves can contain hidden leaps.

Adding the connecting steps makes the reasoning behind each design decision explicit. Checking for breaks reveals where a specification does not actually satisfy the requirement it came from.

8.6 Testing an argument before it is challenged

Repeatedly expanding an argument known to be weak is proposed as a way to find its vulnerable point. The first break reveals the weakness, and the categories in section 5.2 describe what kind of weakness it is.

The paper suggests this use for legal arguments, policy reasoning, and strategic plans before they face challenges in practice.

09 Limits and questions still to be answered

9.1 The checking component can make mistakes

The formal results in this paper assume that the interpolation oracle is correct. A language model is instead a heuristic: it uses a fallible method to look for a bridge, so it can make either of two errors.

It may miss a valid bridge and report a break where none exists. This is a false negative, and its frequency depends on the model and the prompt. It may also produce an invalid bridge and leave a real gap undetected. This false positive is more dangerous because it creates false confidence.

The paper proposes three ways to reduce these risks:

1. Agreement across models. Require k independent language models to agree on the bridge. If they disagree, send the connection for human review.
2. Formal checking. Where possible, translate a proposed bridge into formal logic and check it with a theorem prover.
3. Calibrated confidence. Train a classifier on the oracle’s outputs to estimate the probability that a bridge is valid.

9.2 Ordinary language can have more than one meaning

Craig’s interpolation theorem applies to formal logics whose expressions have precise rules. Ordinary language introduces ambiguity: a word may have several meanings, the placement of words such as “all” and “some” can change a statement’s scope, and what a speaker implies in conversation may differ from what the statement logically entails.

The paper proposes first translating the chain into a partly formal notation. It also proposes treating ambiguity as a break: if whether a bridge works depends on how a step is interpreted, that step needs to be clarified before the reasoning can be accepted.

9.3 Background rules must be declared

Arguments often rely on background rules specific to a subject, such as physical laws, legal precedents, or mathematical definitions. These are the argument’s background theory; using them is not, by itself, sneaking in an extra premise.

n+1 Rationale requires those rules to be declared in the axiom_set parameter. The chain is judged relative to that stated set of rules. Any undeclared rules it relies on are flagged as breaks.

This requirement makes assumptions visible, but it also places a burden on the user: they must know which background rules their argument depends on.

9.4 More detail costs more computation

The chain grows exponentially as full passes add bridges. That growth limits how far a practical implementation can continue. The paper gives the following estimates for a chain that begins with five steps.

The paper proposes four ways to reduce the cost:

• Expand selected connections. Use a lightweight checker to identify suspicious transitions, then add detail only there.
• Find bridges in parallel. Derivations at different positions can run independently when their context is fixed.
• Reuse previous results. A saved bridge can be reused if its surrounding context has not changed.
• Shorten distant context. Summarize earlier, more distant steps to reduce the amount of text the model must process.

9.5 Open research questions

1. Which valid bridge should be chosen?

There is generally more than one valid bridge. Which choice produces the shortest complete chain after later passes? Is there a standard best choice?

2. How should confidence carry through a chain?

How should a bridge’s confidence score be calculated, and how should it affect later steps? Can the whole chain receive a confidence measure that reliably reflects its actual correctness?

3. Can ordinary-language bridges be checked formally?

Can a bridge written by a language model be translated automatically into formal logic for machine verification? This connects to autoformalization, the research field concerned with turning informal mathematical statements into formal ones.

4. Can someone construct a chain that fools the checker?

Can an adversarial generator deliberately create reasoning chains that deceive the densification operator? How much computation would constructing those chains require?

5. Does the required number of passes depend on the subject?

How many passes do mathematics, law, philosophy, and engineering require? Is there a measurable scaling rule describing those differences?

6. When is a bridge unique?

Under what conditions is there only one bridge, treating logically equivalent wordings as the same? When several bridges are possible, does the choice change which breaks are found later?

7. Can the method handle conclusions that may be withdrawn?

Can n+1 Rationale be extended to defeasible or non-monotonic reasoning, where later evidence can overturn an earlier conclusion?

10 How the proposal relates to other work

10.1 Methods that help AI produce reasoning steps

The paper places n+1 Rationale alongside these approaches, distinguishing the job each one is intended to do.

10.2 Formal verification and the study of proofs

10.3 AI safety and alignment

10.4 Other uses of interpolation in computer science

Model checking — McMillan, 2003. Interpolants derived from proofs of inconsistency help build simplified models that safely include all the relevant possibilities. These are used in repeated abstraction-and-refinement checks, known as CEGAR. The paper describes densification as the dual operation: making an argument more concrete by filling in detail instead of making it more abstract.

Program analysis — Heizmann et al., 2010. Interpolant-based trace abstraction uses Craig interpolants to distinguish program paths that can actually occur from paths that cannot. The paper applies the same principle to possible paths through an argument.

Database theory — Nash et al., 2010. Interpolation can reformulate a query using database views. The paper describes an exact structural parallel: finding an intermediate representation that connects two expressions.

10.5 Revising beliefs when a problem is found

The backward trace in section 5.3 is related to AGM belief revision, introduced by Alchourrón, Gärdenfors, and Makinson in 1985. In that setting, new evidence conflicts with an existing set of beliefs, and a revision process identifies which beliefs to withdraw.

Here, the break plays the role of the new evidence and the reasoning chain plays the role of the existing beliefs. The paper characterizes the trace as finding a minimal retraction: the earliest step whose removal or revision resolves the break.

11 What n+1 Rationale proposes

The paper presents n+1 Rationale as a formal method built on five established ideas. It assigns each idea a particular role in explaining why the method should work.

Craig interpolation is presented as the basis for a necessary bridge existing when a transition is valid, with the absence of a bridge signaling a break. Gentzen’s cut elimination describes the proposed endpoint, where the chain’s reasoning has been made fully explicit. Dedekind completeness supplies the convergence analogy through the density of dyadic rationals—numbers obtained by repeatedly dividing intervals in half.

Knaster–Tarski fixed-point theory is presented as establishing the existence and uniqueness of the final refinement, the point at which further refinement changes nothing. Curry–Howard gives the method a computational interpretation: a fully expanded chain is treated as a typed program that constructs a conclusion from its premises.

For the computational operator, the paper reports a per-pass token cost of O(m²), where m is the number of steps and the cost grows quadratically with that number. It claims logarithmic convergence of the largest remaining reasoning gap under Theorem 6.1’s optimal-bridge assumption, provable termination for finite logics in Theorem 4.3, and heuristic termination for natural language. Theorem 4.5 states its soundness and completeness claim for break detection relative to the completeness of the oracle.

The intended contribution as an AI skill is checking each transition. Chain-of-thought prompting asks a model to show its work; n+1 Rationale asks the model, or a separate critic, to check whether each move is logically necessary. The paper describes this as accountable reasoning: each step either passes that scrutiny or is flagged for repair.

The proposed architecture is self-contained and can be combined with other tools. Its four integration patterns cover checking a completed draft, checking during generation, assigning a separate critic, and adding detail through successive passes. The paper presents the JSON schema in section 7.3 as making the operator ready to integrate into agent frameworks that support tool calls.

Practical performance remains an empirical question. The accuracy of the oracle, the rates of missed and incorrectly reported breaks, improvements on downstream tasks, and the number of passes needed in different subjects still need to be measured. The paper offers its formal framework as a basis for designing those experiments, interpreting their results, and testing whether its claims hold.

References

A A guide to the symbols

The paper uses symbols to name the parts of an argument and the operations that make its reasoning more explicit. This reference gives each symbol's meaning and where the paper first defines it.

B How the paper derives its three bounds

B.1 Counting the steps after one pass · Theorem 2.1

A chain containing n + 1 statements has n gaps between neighbouring statements. Inserting one bridge in every gap adds n statements. The original statements and the new bridges therefore total 2n + 1.

B.2 Counting the steps after repeated passes · Theorem 2.2

The proof first checks the count before any pass. It then shows that, whenever the formula holds for one pass count, the same counting rule makes it hold for the next. After k passes, the total is n × 2^k + 1.

B.3 Bounding the number of passes · Theorem 6.1

For a sound chain whose largest reasoning gap has distance d, the paper's proof selects each bridge at the midpoint of a derivation. It argues that this reduces the largest remaining distance to at most half, rounded up. Repeating that reduction reaches a distance of one once the number of passes reaches ⌈log₂d⌉.

D Checking n+1 with its own method

The paper reports a consistency check in which n+1 was applied to the argument supporting n+1 itself. That argument was written as 11 steps, numbered 0–10, in this order:

Tarskian closure → Craig's theorem → definition of a bridge → existence of a bridge → the contrapositive used to detect breaks → definition of the operator → step doubling → gap halving → logarithmic convergence → a cut-free fixed point → soundness and completeness.

Results

The audit recorded nine valid transitions and one break. The validity of transition 7 → 8 was conditional on repairing the earlier break at 6 → 7.

The gap

The break at 6 → 7 was a jump between two different kinds of result. Step doubling counts how many statements the expanded chain contains. Gap halving measures how much reasoning distance a pass removes. The argument moved from the counting result to the distance result without making two requirements explicit:

1. Connect the distance measure to the operation. The inferential-distance measure in Definition 3.2, introduced in §3.3, needed a formal link to how the operator works.
2. Require the stronger bridge-selection rule. The convergence bound needs an oracle that chooses bridges optimally for inferential distance. Finding any valid bridge is a weaker requirement.

The basic oracle contract supports the paper's qualitative results: whether bridges exist, whether breaks can be detected, and soundness and completeness. Its quantitative results—the convergence rate and logarithmic bound—need the stronger optimal-oracle assumption. Version 2.1 states a distinction that the original version had left implicit.

The repair

Version 2.1 made three changes to state the missing connection:

1. Remark 3.4 in §3.3. This addition explains that inferential distance is a separate basic measure from the framework that decides validity. It points forward to the extra convergence assumption formalised in §4.6.
2. §4.6, “The Optimal Oracle Contract.” Added after §4.5 and before §5, this section defines the optimal oracle in Definition 4.7, proves the bisection bound in Proposition 4.7, and states that the contract is strictly stronger than the basic one. It also states that suboptimal oracles still converge, but take longer.
3. An assumption block at the start of §6. This makes the optimal-oracle contract in Definition 4.7 an explicit assumption for every convergence result in that section.

What the paper takes from this audit

The paper presents the audit as evidence of three properties:

1. The method can examine itself. Its own supporting argument can be checked without giving it an exemption or relying on circular reasoning.
2. The check found a substantive gap. The reported issue was the missing connection between counting steps and measuring reasoning distance, rather than a formatting problem or an incorrect alert.
3. The method can support correction. Stating the missing definitions and assumptions as explicit steps repaired the gap. The paper describes this as strengthening its support without changing its conclusions.

The paper argues that a method would undermine its own verification claim if it accepted its flawed supporting argument without identifying the flaw. It describes n+1 as self-correcting because this audit identified a real gap and led to a repair.