Thinking with Drafting: Optical Decompression via Logical Reconstruction

🎯 Pitch

An 8B model fine-tuned to draft its reasoning into executable diagram code surpasses all proprietary giants on a visual algebra benchmark—including Gemini-3-Pro—by replacing guesswork with deterministic self-verification. The key insight is that forcing the model to explicitly reconstruct the logical topology of a problem as a minimalist diagram acts as a necessary cognitive scaffold, slashing hallucinations that even the strongest vision-language models cannot avoid.

1. Executive Summary

This paper introduces Thinking with Drafting (TwD), a paradigm that reconceptualizes visual reasoning as optical decompression—the reconstruction of latent logical structures from compressed visual tokens—by forcing models to draft their mental models into an executable Domain-Specific Language (DSL) that serves as a deterministic visual verifier. Evaluated on VisAlg, a custom visual algebra benchmark built around bar-model reasoning, TwD is instantiated by fine-tuning Qwen3-VL-8B to generate structured DSL programs that encode entity primitives, relational primitives, and aggregation primitives, then rendering those programs as mathematically exact diagrams for self-verification. A compact 8B model equipped with TwD achieves an overall composite score of 82.63 on VisAlg, outperforming not only all open-weight baselines but also the strongest proprietary models including Gemini-3-Pro (79.96) and Gemini-2.5-Pro (74.12), establishing that explicit structural drafting provides a necessary cognitive scaffold for trustworthy visual reasoning—though only when the underlying DSL is scoped to the topological constraints of the target diagram class.

2. Context and Motivation

The Core Problem: The Precision Paradox in Multimodal Reasoning

The paper addresses a fundamental disconnect in how modern multimodal systems handle tasks requiring rigorous logical precision. The authors frame this as a precision paradox (Section 1): on one side, optical character recognition (OCR) and vision-language models have achieved remarkable fidelity in transcribing visual information—they can extract symbols, numbers, and text from images with high accuracy. On the other side, visual generation models can produce diagrams, sketches, and intermediate images as part of a reasoning process. Yet when these capabilities are combined for tasks like mathematical problem solving, a critical gap emerges: transcription captures symbols without capturing the logical relationships between them, and generated images optimize for perceptual plausibility rather than mathematical exactness.

The paper crystallizes this paradox with a concrete example. An OCR system might faithfully extract the numeral "123" from an image, but it cannot tell you whether that number represents a total, a difference, a multiplicative factor, or a constraint. The perceptual signal is high-fidelity, but the relational semantics remain implicit and unstructured (Section 1). Similarly, a visual generation model might produce a diagram where one line segment looks longer than another, but it cannot guarantee that the lengths satisfy a precise quantitative ratio like $3:1$ . The diagram is perceptually plausible but mathematically unverifiable.

This gap is not a minor implementation detail—it represents a category error in how we conceive of reasoning over visual inputs. The paper's central reframing is that we should not think of visual reasoning as "read the text, think about it, and optionally draw a picture." Instead, reasoning over visual inputs should be understood as optical decompression: if OCR compresses the visual world into perceptual tokens, then reasoning is the act of reconstructing the latent logical structure that was encoded in those tokens (Section 1). Understanding, from this perspective, is not about producing fluent textual explanations—it is about recovering an explicit, executable representation of entities, relations, and constraints.

This leads to the paper's central axiom: Parsing is Reasoning. True comprehension arises only when a model can translate ambiguous natural language and visual cues into a structured, verifiable form. The paper argues that without such a structured intermediate representation, even state-of-the-art multimodal models are fundamentally doing pattern matching rather than logical reconstruction—they may get the right answer for the wrong reasons, or produce reasoning chains that are internally inconsistent but superficially plausible.

Why This Problem Matters

The paper motivates the importance of this problem along three dimensions: trustworthiness, generality, and the trajectory of the field.

Trustworthiness. In domains where reasoning errors have real consequences—mathematical proofs, financial calculations, engineering design, scientific analysis—it is not sufficient for a model to be correct most of the time. We need verifiable correctness. The paper argues that purely textual chain-of-thought reasoning is fundamentally unverifiable by its nature: natural language is ambiguous and lacks strict geometric or logical constraints (Section 3.1). A model might write "therefore, x = 42" but there is no mechanical way to check whether that conclusion follows from the stated premises without a human reading and evaluating the entire reasoning trace. By contrast, a programmatic DSL that can be deterministically rendered and mechanically verified against structural invariants provides a closed verification loop. If the generated diagram violates a topological constraint (e.g., two segments that should be aligned are not), the error is detectable automatically, without human judgment.

This vision of "visual generation as verification rather than creativity" represents a shift in how we should think about the role of generated images in reasoning systems. The paper is explicit: "Within TwD, drafting is not treated as a final output but as a deterministic visual verifier" (Section 1). This reframes the output side of multimodal models from "here is a helpful illustration" to "here is a proof that my reasoning is structurally sound."

Generality. The paper suggests that the precision paradox is not unique to the bar-model visual algebra domain they study. It manifests whenever a task requires maintaining global structural invariants under local transformations—a class of problems that includes geometry, physics, chemistry, and any domain where quantitative relationships must satisfy consistency constraints. The failure mode they identify—models producing outputs that are arithmetically compatible but topologically inconsistent—is likely widespread in scientific and mathematical applications of multimodal models. Addressing it at a fundamental level through structured intermediate representations could have broad impact.

The trajectory of the field. The paper identifies two converging trends in multimodal AI that set the stage for their work. The first is the dramatic improvement in OCR and document understanding (Section 2.1): models can now faithfully transcribe dense text, structured layouts, tables, and mathematical formulas from images. The second is the emergence of "thinking with images" paradigms (Section 2.2), where models generate visual artifacts as part of reasoning. The paper argues that these trends are approaching a read–draw loop—perception supplying faithful inputs, generation enabling visualized intermediate states—but that this loop will be logically hollow unless the intermediate representations enforce structural invariants. The paper positions TwD as the missing piece that turns the read–draw loop from a creative exercise into a verifiable reasoning process.

Prior Approaches and Where They Fall Short

The paper situates its contribution against three dominant paradigms, each of which it argues is insufficient for rigorous visual reasoning.

Text-Only Chain-of-Thought (CoT) and Program-of-Thought (PoT)

The standard approach to multimodal reasoning uses large language models to decompose problems into step-by-step textual deductions (Chain-of-Thought; Wei et al., 2022) or executable code snippets (Program-of-Thought; Chen et al.; Gao et al., 2023). These methods have proven effective for many reasoning tasks, but the paper identifies a fundamental limitation: natural language is ambiguous and lacks strict geometric constraints (Section 3.1). When a model produces a textual reasoning chain about a visual algebra problem, there is no mechanism to enforce that the entities, relations, and quantities it references are consistent with each other. The model might correctly compute an answer while maintaining an internally contradictory mental model of the problem structure.

The paper formalizes this contrast in Section 3.1: in CoT, the reasoning trace $\hat{t}_{cot} \in \mathcal{T}$ lives entirely in the space of unstructured natural language $\mathcal{T}$ . The model maps $(I, Q) \rightarrow \hat{t}_{cot} \rightarrow \hat{a}$ . Natural language, by design, tolerates ambiguity—the same phrase can mean different things in different contexts. But reasoning about quantitative relationships requires the opposite: every term must have a precise, unambiguous referent. The paper argues that CoT's reliance on language as the reasoning medium means it cannot enforce the logical rigidity that visual algebra demands.

Program-of-Thought partially addresses this by using executable code (e.g., Python) as the reasoning medium. Code is less ambiguous than natural language, but it still operates at the level of arithmetic operations—it can compute the right answer without encoding the spatial and topological structure of the problem. For example, Python code can compute that $12 \times 124 = 1488$ without representing why the multiplicative relationship holds, or how the parts relate to the whole. The paper positions its DSL as a higher standard: the DSL must encode not just the computation but the visual topology that justifies it.

Thinking with Images

A more recent paradigm, exemplified by works like Su et al. (2025) and Chern et al. (2025), incorporates visual generation into the reasoning process itself. Rather than reasoning purely in text or code, these models generate diagrams, sketches, or intermediate images as part of their chain-of-thought. The motivation is compelling: humans often use drawing and visualization as tools for thought, so perhaps models should too.

The paper acknowledges the appeal of this approach but identifies a critical weakness: generated images operate in pixel space, which suffers from stochastic imprecision (Section 3.1). A model may generate a diagram that looks correct—bars that appear proportional, lines that appear aligned—without the underlying relationships being mathematically exact. The paper formulates this as:

"A model may generate a diagram that is perceptually plausible but mathematically inaccurate."

The distinction is between perceptual plausibility (does it look right?) and logical validity (is it provably consistent?). In pixel-space generation, the same stochastic process that enables creative variation also prevents exact verification. A line segment might be approximately $3\times$ longer than another, but you cannot prove it is exactly $3\times$ from pixel measurements alone. This makes "thinking with images" inherently unsuitable for tasks where the reasoning chain must be rigorous.

The paper's DSL-based approach directly addresses this: by generating symbolic code that is deterministically rendered, every visual property of the output diagram is provably correct relative to the problem constraints. If a segment is rendered with length proportional to 12 units, the rendering engine guarantees that the pixel length is exactly proportional—not approximately.

OCR: Transcription Without Understanding

The paper characterizes OCR as addressing the question "What is written?" rather than "What does it mean?" (Section 3.1). Modern OCR systems can faithfully extract symbols and text from images, but they operate at the level of syntax: they capture the visual surface of the document without interpreting the logical relationships between extracted elements. The paper argues that this is a category error: extracting text from an image of a word problem is not the same as understanding the problem. The entities ( $A$ has $x$ apples, $B$ has $y$ apples), their relationships ( $A$ has 3 times as many as $B$ ), and the query (how many do they have together?) must be explicitly modeled—transcription alone leaves these relationships implicit and ungrounded.

The paper positions TwD as addressing the gap that OCR leaves: after the text is extracted, the model must parse it into a structured representation that makes the logical topology explicit. This is the optical decompression step—decompressing the compressed visual tokens back into their latent logical structure.

How This Paper Positions Itself Relative to Existing Work

The paper's positioning is distinctive because it does not propose a better OCR system, a better chain-of-thought method, or a better image generation model. Instead, it introduces a new intermediate representation layer—the Logic Graphic DSL—that sits between perception and reasoning, and between reasoning and generation. This DSL is designed to occupy a "unique strategic niche" (Section 1) that bridges several gaps simultaneously:

Between ambiguity and rigidity. The DSL mediates between the ambiguity of natural language, the syntactic noise of general-purpose code, and the rigidity of geometric axioms. It is more structured than natural language (each DSL primitive has a precise geometric interpretation), yet more abstract than raw pixel coordinates (entities are specified in terms of logical relationships, not absolute positions).

Between perception and generation. The DSL serves as both the target of the perceptual parsing process (the model must generate DSL code from visual input and natural language) and the source for the rendering process (the DSL is compiled into a verifiable diagram). This creates a closed loop where the same structured representation grounds both understanding and verification.

Between human and machine verification. Because the DSL renders into human-readable diagrams, it supports both automated verification (checking structural invariants programmatically) and human verification (inspecting the visual output). The paper emphasizes that the generated draft provides "an explicit visual proof of the model's internal reasoning for human verification" (Section 3.4). This dual verifiability is a significant advantage over purely textual reasoning chains, which can only be verified by reading and evaluating the entire trace.

Empirically, the paper demonstrates that this positioning matters. The results in Table 2 show that open-weight models fine-tuned on the DSL generation task (TwD, based on Qwen3-VL-8B) leapfrog even the strongest proprietary models that lack explicit structural supervision. This is not a marginal improvement—TwD achieves 82.63 overall score compared to 74.12 for Gemini-2.5-Pro and 66.60 for GPT-5.1. The paper interprets this as evidence that the DSL provides a cognitive scaffold that general-purpose multimodal models cannot replicate through scale alone: "This highlights the importance of explicit supervision on logic reconstruction for verifiable bar-model reasoning" (Section 5.2).

A notable philosophical commitment. The paper makes a strong claim that goes beyond engineering: that parsing IS reasoning—not a precursor to reasoning, not a tool that supports reasoning, but the reasoning process itself. The act of translating an ambiguous problem statement into a structured DSL program is the act of understanding the problem. The final answer is then a "derivative of a verified logical structure" (Section 3.4). This contrasts with approaches that separate "understanding" from "solving"—in TwD, there is no such separation. The model demonstrates its understanding by constructing the DSL, and the solution follows mechanically from the verified structure.

The scope is deliberate and acknowledged. The paper restricts its DSL to bar-model visual algebra, a domain where the topological constraints are well-understood and the number of primitive operations is small. This is both a strength (the DSL can be made rigorous and verifiable) and a limitation (the approach does not directly transfer to arbitrary diagram types). The paper is candid about this in its Limitations section, noting that "extending this DSL to support broader classes of scientific diagrams remains an important direction for future research." This scoping is strategic: it allows the paper to make a clean, falsifiable claim about a specific domain while establishing a paradigm that can be extended. The success of the approach on set-theoretic reasoning tasks (Section 5.5, Figure 7) provides preliminary evidence that the paradigm may generalize beyond bar models, though the paper is appropriately cautious about overclaiming.

3. Technical Approach

3.1 Reader orientation (approachable technical breakdown)

The paper builds a visual algebra reasoning system called Thinking with Drafting (TwD) that takes an image of a word problem as input and produces both the correct answer and a mathematically exact structural diagram proving that the answer is logically consistent. The system solves the precision paradox—where multimodal models can transcribe symbols from images but cannot preserve the logical relationships between them—by forcing the model to draft its understanding into an executable Domain-Specific Language (DSL) that encodes entities, relations, and quantitative constraints as structured primitives, then renders those primitives into a deterministic visual proof that can be verified for topological consistency.

3.2 Big-picture architecture (diagram in words)

The TwD system has five interconnected components arranged as a generation-verification pipeline:

Visual Input Parser — takes the raw image $I$ (containing visual text, layout, and geometry) and a natural language query $Q$ as input; extracts perceptual information including text content, layout structure, and symbolic notation (e.g., numbers, mathematical expressions). This is conceptually similar to OCR but with awareness that subsequent processing needs semantic grounding, not just character sequences.
Logic Graphic DSL Generator (Stage 1) — the core neural component, parameterized by a multimodal large language model (Qwen3-VL-8B, fine-tuned), which produces a preliminary textual explanation $\hat{t}$ and an initial structured DSL program $\hat{s}$ that decomposes the problem's logical topology into atomic primitives (entity segments, relational alignment markers, and aggregation braces). The DSL generation is not a single output but a step-by-step decomposition reflecting the axiom that parsing is reasoning.
Topological Abstraction Layer — a virtual grid system that decouples logical reasoning from metric rendering by mapping continuous pixel coordinates $\mathbb{R}^2$ to a discrete logic space $\mathbb{Z}^2$ , where entities are assigned to logical rows and relative offsets rather than absolute pixel positions. This ensures layout invariance: the model focuses on logical ordering and grouping rather than precise coordinate calculation.
Deterministic Rendering Engine — takes the syntactically correct DSL statement $\hat{s}$ and produces a verification image $\mathcal{V} = \text{Render}(\hat{s})$ using geometric macros that enforce canonical diagram conventions. Because the renderer is deterministic and mathematically exact, every visual property (segment lengths, alignment, bracketing) is provably correct relative to the encoded constraints.
DSL-Conditioned Inference (Stage 2) — the model receives the rendered draft as visual feedback and generates a refined explanation $\hat{t}_2$ , a completed DSL $\hat{s}_2$ , and the final answer $\hat{a}$ . Critically, the model conditions its reasoning on the structured draft it constructed, using the explicit topology as a cognitive scaffold that guides computation.

Information flows sequentially: image + question → parser → initial draft (DSL + text) → renderer → verification image → refined reasoning → final answer. The rendered image provides an explicit visual proof that both the model and a human can inspect for structural correctness.

3.3 Roadmap for the deep dive

The formal mathematical framework (Section 3.1) — understand the probabilistic formulation of TwD as a multi-stage generation process, including how it contrasts with Chain-of-Thought, Thinking with Images, and OCR to establish what is structurally different about TwD's intermediate representation.
The Logic Graphic DSL specification (Section 3.2) — the three categories of primitives (Entity, Relational, Aggregation) and their geometric semantics, including the status-aware segmentation mechanism and alignment constraints that make the DSL executable.
The Topological Abstraction layer (Section 3.3) — the virtual grid system and deterministic rendering engine that decouple logical reasoning from pixel-level coordinate generation, solving the high-entropy problem of continuous coordinate spaces.
The two-stage Thinking with Drafting process (Section 3.4) — how optical decompression via logical parsing (Stage 1) and DSL-conditioned inference (Stage 2) work together to create a closed-loop system where drafting serves as both reasoning engine and visual verifier.

3.4 Detailed, sentence-based technical breakdown

This is a methodology paper that introduces a new reasoning paradigm for multimodal models: rather than reasoning in natural language or generating approximate visualizations, the model must construct an executable structured program whose deterministic rendering serves as a correctness proof. The core idea is that parsing into a structured representation IS the reasoning process itself—not a precursor to reasoning—and that this structured representation, when combined with deterministic rendering, creates a closed verification loop that enforces logical consistency.

Formal Framework: Probabilistic Multi-Stage Generation

The paper formalizes TwD as a multi-stage iterative generation process involving a structured intermediate representation space $\mathcal{S}$ (the DSL) distinct from the space of unstructured natural language $\mathcal{T}$ (Section 3.1). A multimodal large language model $P_\theta$ , given visual input $I$ (images containing text, layout, and geometry) and a natural language query $Q$ , must produce a correct answer $a \in \mathcal{A}$ by passing through a structured intermediate state.

Stage 1 — Optical Decompression via Logical Parsing. The model acts as a parser, perceiving the raw input and decompressing implicit logical topology into an explicit structural draft:

$(\hat{t}, \hat{s}) \sim P_\theta(t, s \mid I, Q)$

where $\hat{t} \in \mathcal{T}$ is a preliminary textual explanation (a natural language analysis of the problem schema), and $\hat{s} \in \mathcal{S}$ is an initial DSL draft encoding the recovered logical structure as atomic reasoning primitives.

What this equation computes: the joint distribution over possible (text analysis, DSL program) pairs given the visual input and query. The sampling operation produces a single pair $(\hat{t}, \hat{s})$ that represents the model's best attempt at parsing the problem into a structured form. The text component makes the model's interpretation explicit; the DSL component makes it executable and verifiable.

Why this form: the joint generation ties textual analysis to structural encoding—the model cannot produce a DSL without first understanding what the problem entities and relations are, and the text analysis ensures the DSL construction is grounded in explicit semantic parsing rather than pattern-matched code generation. This contrasts with approaches that generate code independently of explanatory reasoning, which risks producing syntactically valid but semantically unmoored programs.

Stage 2 — DSL-Conditioned Inference. The model receives its own rendered draft as visual feedback and produces a refined reasoning trace along with the final answer:

$\hat{a} \sim P_\theta(t, s, a \mid I, Q, \hat{t}, \hat{s})$

where $\hat{a}$ is the final answer, conditioned on the initial draft $(\hat{t}, \hat{s})$ as an externalized cognitive scaffold.

What this equation computes: the distribution over possible answers and refined DSL programs, conditioned on all prior information including the model's own initial draft. The model inspects its own reasoning by conditioning on the structured representation it constructed, using the explicit topology as a constraint on subsequent computation.

Why this form: this two-stage design separates the tasks of structural parsing (what is the logical topology of the problem?) from computational inference (what arithmetic operations follow from that topology?). The first stage resolves semantic ambiguity into discrete logical atoms; the second stage performs deterministic computation on those atoms. The conditioning on $\hat{s}$ ensures that calculations are guided by the explicit topology rather than by implicit, potentially inconsistent mental models.

The paper explicitly contrasts this formulation with three alternatives to establish theoretical distinctiveness:

Contrast with Text-Only Chain-of-Thought. Standard CoT relies exclusively on the linguistic space $\mathcal{T}$ :

$\hat{t}_{cot} \sim P_\theta(t \mid I, Q), \quad \hat{a} \sim P_\theta(a \mid I, Q, \hat{t}_{cot})$

where $\hat{t}_{cot} \in \mathcal{T}$ is a linear sequence of natural language tokens. The fundamental limitation the paper identifies is that natural language is ambiguous and lacks strict geometric constraints—there is no mechanism to enforce that the entities, relations, and quantities referenced in the reasoning chain are mutually consistent. A CoT trace might describe a multiplicative relationship between quantities while implicitly assuming an additive structure, and there is no automated way to detect this inconsistency from the text alone. In TwD's formulation, the DSL enforces logical rigidity: a defined entity in $\mathcal{S}$ must satisfy explicit geometric rules, acting as a regularizer for the reasoning process. If a segment is declared with a specific proportional relationship to another segment, the DL grammar requires that this relationship be topologically encoded (e.g., through repeated equal-length subsegments), making deviations from logical consistency syntactically invalid.

Contrast with Thinking with Images. Approaches that generate intermediate images produce pixel-space outputs:

$\hat{a} \sim P_\theta(a \mid I, Q, \hat{I}_{gen})$

where $\hat{I}_{gen}$ is a generated intermediate image. The paper identifies the key weakness as stochastic imprecision—the generated image operates in pixel space, where relationships are approximate rather than exact. A model may generate a diagram where one bar appears approximately $3\times$ longer than another, but the pixel measurements cannot prove exact proportionality. TwD employs programmatic drafting: the intermediate representation $\hat{s}$ is symbolic code that deterministically maps to a rendered image. Every visual property is mathematically exact because the rendering engine guarantees geometric constraints—if the DSL specifies three equal-length segments, the renderer produces exactly three equal-length segments, down to the pixel. There is no stochastic variation or approximation.

Contrast with OCR. OCR addresses the question "What is written?" by mapping the visual input to character sequences:

$\text{Seq} \sim P_\theta(\text{Seq} \mid I)$

The paper argues this captures syntax without semantics—the extracted text preserves the surface form but leaves entities, relations, and quantities implicit and ungrounded. TwD addresses the question "What does it mean?" by performing logical reconstruction: the mapping $I \rightarrow \mathcal{S}$ explicitly captures the logical topology that OCR ignores. An OCR system might extract "John has 3 times as many apples as Mary" as a string; TwD must parse this into (Entity: John's apples, Entity: Mary's apples, Relation: multiplicative $\times 3$ , Query: total sum) and encode these primitives as geometrically grounded DSL constructs.

The Logic Graphic DSL: Three Categories of Atomic Reasoning Primitives

The paper introduces a minimalist Domain-Specific Language (DSL) designed to abstract away rendering redundancies and expose the bare logical topology of bar-model visual algebra problems (Section 3.2). A statement $s \in \mathcal{S}$ is not a sequence of natural language tokens but a structured composition of atomic reasoning primitives—each primitive has a precise geometric interpretation and enforces specific logical constraints. The DSL consists of three fundamental operator categories:

Entity Primitives (HL — Horizontal Lines)

Entity primitives represent the physical quantities or objects from the input $I$ as horizontal line segments. The key innovation is status-aware segmentation: the model generates a segment sequence vector $\mathbf{v} = [v_1, v_2, ..., v_n]$ , where $|v_i|$ denotes the length of segment $i$ , and the sign of $v_i$ encodes existential status:

$v_i > 0$ renders a solid line, representing an existing quantity (e.g., the current amount of something, a known value).
$v_i < 0$ renders a dashed line, representing a process quantity (e.g., a subtracted part, a hypothetical extension, a counterfactual transfer).

Why this design matters. The sign-based encoding allows a compact representation of complex change models—for example, a "give away 5 apples" operation can be represented by appending a negative-length segment $v = -5$ to an entity, which the renderer will display as a dashed subtraction from the solid portion. Without this mechanism, the model would need separate primitives for "current state" and "change operation," increasing DSL complexity and making the correspondence between code and visual representation harder to verify. This design directly supports the Change & Revert schema in VisAlg (Section 4.2), where problems involve counterfactual transfers—the paired solid/dashed segments visually distinguish initial state from the hypothetical operation, enabling the DSL to encode dynamic temporal states within a static spatial diagram.

Relational Primitives (VL — Vertical Lines)

In bar models, logic is primarily defined by geometric alignment—segments from different rows that share a boundary represent quantities that are equal at that point. The Vertical Line (VL) operator explicitly encodes relational equality between horizontal entities by specifying an x-coordinate and the set of row indices that should share that coordinate as a common boundary.

What it enforces. A VL operator functions as an equality constraint: it asserts that the right endpoints (or left endpoints) of the specified segments from different rows coincide at the same x-position. This compels the model to perform alignment reasoning—identifying which entities share semantic boundaries rather than treating coordinates as independent variables. For example, in a "Difference Analysis" problem where "A has 30 more than B," the model must generate a VL at the point where B's bar ends and A's exceeds it by 30 units. The VL does not just label this relationship; it enforces it geometrically.

Why this is different from coordinate assignment. In general-purpose plotting code (e.g., Matplotlib or SVG), the model would manually assign numerical x-coordinates to each segment boundary. This creates a high-entropy generation problem because the model must compute exact pixel positions that satisfy all constraints simultaneously. By contrast, VL operators specify logical relationships (these endpoints are equal) and leave the coordinate computation to the deterministic renderer. This decouples the logical task (identifying which boundaries align) from the metric task (computing where they fall on the canvas), significantly reducing the complexity of DSL generation.

Aggregation Primitives (HB and VB — Horizontal and Vertical Braces)

To ground abstract arithmetic operations into geometry, the DSL employs Horizontal Braces (HB) and Vertical Braces (VB):

HB operator: encapsulates a part-whole relationship within a single entity. It spans across a set of consecutive subsegments and annotates the total length, representing operations like summation of parts (e.g., "A gave 5 to B, then A had 25 left—how many did A start with?" requires a total bracket spanning the given-away portion and the remainder).
VB operator: represents summation or comparison across multiple entities. It spans vertically across multiple rows (representing different objects or categories) and annotates the aggregate quantity, encoding operations like "total across all categories" or "difference between two categories."

Why braces are first-class primitives. Rather than treating aggregation as a cosmetic label added after the fact, the DSL treats HB and VB as semantic operators that explicitly ground arithmetic operations in geometry. An HB bracket at a specific position with a specific span means that the quantities represented by the spanned segments sum to the annotated total. A VB bracket spanning specific rows means that the quantities in those rows are being compared or aggregated. This makes the arithmetic structure of the problem visible and verifiable in the rendered diagram: a human (or automated checker) can verify that the bracket endpoints coincide with the correct segment boundaries and that the annotation matches the intended operation.

For instance, the triplet of brackets (HB for part-whole within a row, VL for alignment across rows, VB for aggregation across rows) collectively encode the complete logical topology of a bar-model problem. If any of these primitives is misplaced or missing, the rendered diagram will exhibit a structural inconsistency detectable through automated verification.

Topological Abstraction and Deterministic Rendering

A major bottleneck in generating visual code is the high entropy of continuous coordinate spaces—if the model had to generate exact pixel coordinates for every segment boundary, bracket, and alignment marker, the generation task would require solving a complex constraint satisfaction problem in addition to parsing the logical structure. The paper addresses this with a Topological Abstraction layer that decouples logical reasoning from metric rendering (Section 3.3).

Virtual Grid System

The continuous canvas $\mathbb{R}^2$ is mapped to a discrete logic space $\mathbb{Z}^2$ using a virtual grid:

The y-axis is discretized into logical rows, with each entity being assigned to a row_id rather than a pixel offset. This eliminates the need for the model to compute vertical positioning—it simply specifies which logical row a new entity occupies.
The x-axis is governed by relative offsets rather than absolute pixels. Segments are specified in terms of their lengths relative to each other, and alignment operators (VL) specify which segment boundaries coincide in x-position.

Layout invariance. Because positions are specified logically rather than metrically, the model focuses solely on the logical ordering and grouping of entities. It does not need to compute whether a segment should be at x=147 or x=153—it only needs to specify that segment A ends where segment B begins (via a VL operator at that boundary), and the renderer handles the exact coordinate computation. This design eliminates an entire class of errors (pixel-level misalignment) that would plague coordinate-based code generation, making the DSL generation task focused purely on logical parsing.

Deterministic Rendering Engine

The mapping from a syntactically correct DSL statement to a visual verification image is executed by a deterministic rendering engine:

$\mathcal{V} = \text{Render}(s)$

where $\mathcal{V}$ is the output image and $s \in \mathcal{S}$ is the DSL program. The renderer is deterministic: given the same DSL program, it always produces the identical image. It is mathematically exact: segment lengths are proportional to their specified values, alignment markers precisely coincide with segment boundaries, and brackets exactly span their intended subsegments. There is no stochastic variation, approximation, or pixel-level imprecision.

Semantic macros. The paper introduces common topological patterns as built-in macros that abstract away recurring geometric constructions. For example, a "comparison pattern" macro automatically generates the difference brace and alignment lines when the model detects a "more than" or "fewer than" relation between two entities. Rather than the model manually constructing a VL at the reference point, a VB spanning both rows, and an annotation for the difference, the macro encapsulates this entire pattern. The model only needs to specify the two entities being compared and the difference quantity—the macro handles the geometric construction.

Why macros matter for verification. Macros ensure that correct logical parsing always yields a visually canonical diagram. If two problems have the same logical structure (e.g., "A has more than B" with different quantities), the rendered diagrams will be structurally identical up to segment lengths. This canonical form makes automated verification easier—the checker can look for specific topological patterns (e.g., a VL at the B-endpoint, a VB spanning the excess portion) rather than reasoning about arbitrary geometric arrangements. It also makes human verification more reliable because deviations from the canonical form immediately signal logical errors.

The virtual grid and deterministic renderer together solve the "high-entropy coordinate" problem. The model operates entirely in logical space (row_ids, relative lengths, alignment constraints), and the renderer handles the metric computation. This design choice is what makes the DSL generation task tractable for an 8B parameter model—the model is doing structural parsing, not geometry computation.

The Two-Stage Thinking with Drafting Process

Building on the DSL specification and the deterministic renderer, the TwD framework instantiates as a sequential generation-verification process with two stages (Section 3.4, Figure 2).

Stage 1: Optical Decompression via Logical Parsing

The model receives the raw perceptual input—the image $I$ containing the word problem's text and possibly diagrams, plus the natural language query $Q$ —and acts as a parser. Its task is to decompress the implicit logical topology that is compressed within the visual tokens (hence "optical decompression") into an explicit structural draft.

The model first produces a step-by-step decomposition of the problem. It identifies:

What entities exist (the objects or quantities in the problem)
What relationships hold between them (multiplicative, additive, comparative)
What constraints are stated (given values, known totals, comparative statements)
What is being asked (the target quantity)

This decomposition is expressed through a preliminary textual explanation $\hat{t}$ that makes the parsing explicit, and simultaneously through an initial DSL draft $\hat{s}$ that encodes the recovered structure as reasoning primitives.

Crucially, the generation of $\hat{s}$ is not a single-shot output—it is a step-by-step construction that embodies the axiom that parsing is reasoning. For example, in a difference analysis problem (as shown in Figure 19), the model does not generate the entire DSL in one pass. Instead, it proceeds operationally:

Instantiate objects (Oper 1-3 in Figure 19: create horizontal segments for each entity)
Enforce topological alignment (Oper 4: place VL operators at shared boundaries)
Encode comparative relations (Oper 5-7: add offset segments and difference brackets for "more than/fewer than" relations)

Each operation adds a new primitive to the accumulating DSL structure. The text analysis alongside each operation explains why that primitive is being added, grounding the DSL construction in explicit semantic parsing. By the end of Stage 1, the model has produced an initial structural hypothesis $\hat{s}$ and an explanation $\hat{t}$ of how it arrived at that structure.

Verification drafting. The generated DSL hypothesis $\hat{s}$ is immediately passed to the deterministic rendering engine, producing the verification drafting image $\mathcal{V}$ . This image provides an explicit visual proof of the model's internal reasoning—it shows, geometrically, what the model believes the logical structure of the problem to be. If the model has misinterpreted a multiplicative relationship as additive, the visual proof will show wrong-length segments or missing repeated units. If the model has misaligned shared boundaries, the visual proof will show broken vertical alignment.

The paper emphasizes that this verification is available for human inspection as well as automated checking. The rendered diagram is a standard bar-model representation that a human expert can evaluate at a glance—unlike textual reasoning traces, which require reading and mentally reconstructing the implied structure, the visual proof makes structural correctness (or incorrectness) immediately apparent.

Stage 2: DSL-Conditioned Inference

In the second stage, the model receives its own rendered draft as context—the visual proof becomes part of the input. Conditioned on this visual feedback plus the initial text analysis and DSL, the model generates:

A refined explanation $\hat{t}_2$ that may correct errors identified through visual inspection
A completed DSL $\hat{s}_2$ that incorporates any corrections and finalizes all structural details (e.g., adding query brackets for the target quantity)
The final answer $\hat{a}$ , computed from the verified structure

The key innovation is that the model's reasoning in Stage 2 is grounded in the explicit topology defined in the draft. Rather than reasoning about quantities in the abstract (as CoT would), the model reasons about quantities as they are physically encoded in the bar-model structure. For example, it does not think "A has 30 more than B, so A = B + 30"; it thinks "A's bar extends to the right of B's bar by a segment labeled 30, so the excess portion corresponds to the difference bracket." This geometric grounding means that calculations follow from the verified structure rather than from an unverified mental model.

The internal model serves as a cognitive scaffold. The paper describes the draft as an "externalized cognitive scaffold" that allows the model to inspect its own reasoning (Section 3.4). This is more than just a helpful visualization—it is the mechanism by which the model detects and corrects logical errors. If Stage 1 produced a misalignment (e.g., a VL at the wrong boundary), the rendered diagram will make this misalignment visible, and the model can detect it in Stage 2 by comparing the visual proof against its textual analysis. The two stages together create a self-verification loop: the model generates a structural hypothesis, visualizes it, inspects the visualization, and corrects errors.

Why two stages rather than end-to-end generation. The separation into two stages is crucial for error detection. In an end-to-end approach that generates the DSL and answer in one pass, errors in the DSL would be invisible to the model because it never "sees" the rendered diagram. In TwD, the rendered diagram becomes part of the model's input context in Stage 2, enabling it to detect topological inconsistencies that would pass unnoticed in a purely text or code-based verification process. The paper provides qualitative evidence for this in Appendix C and D, where the error analysis shows baseline models generating outputs that are arithmetically compatible but topologically broken (e.g., Figure 23's alignment conflict where a vertical guideline implies one boundary while dashed completion implies another).

Training Procedure: Supervised Fine-Tuning on DSL Generation

The paper does not train a system from scratch or use reinforcement learning. Instead, it takes an off-the-shelf multimodal model (Qwen3-VL-8B) and performs supervised fine-tuning (SFT) on the VisAlg training dataset to teach the model to generate DSL programs (Section 5.1).

Base model initialization. The model is initialized from Qwen3-VL-8B (Bai et al., 2025b), a state-of-the-art open-weight multimodal large language model. This provides strong pretrained capabilities in both visual perception (the model already understands images and can extract text from them) and instruction following (the model already knows how to generate structured outputs from natural language instructions). The fine-tuning does not need to teach the model to see or read—it only needs to teach it to parse into the DSL.

Training data. The model is fine-tuned on the 10,430 training instances from VisAlg (Section 4.2, Table 1). Each instance consists of:

An image of a bar-model word problem (the input)
A ground-truth DSL program (the target output)
A ground-truth answer (the target answer)

The paper specifies that training uses a visual token cap of 2,048 and a maximum sequence length of 5,128 tokens. This caps the amount of visual information the model processes per instance (preventing memory overflow from large images) and the total length of the generated output.

Training configuration. The paper provides specific hyperparameters:

Hardware: 8-GPU node
Epochs: 2
Learning rate: $5 \times 10^{-6}$
Warmup ratio: 0.05

The warmup ratio of 0.05 means the learning rate linearly increases from 0 to $5 \times 10^{-6}$ over the first 5% of training steps, then decays according to a schedule (specific decay method not specified in the paper). This is a standard practice in LLM fine-tuning to prevent catastrophic forgetting in the early training steps, where large gradient updates could destabilize the pretrained representations.

What the model learns. The fine-tuning teaches the model to generate, given an image of a word problem, a sequence of tokens representing:

A textual analysis that parses the problem schema (identifying entities, relations, constraints, and the query)
A DSL program that encodes this analysis as atomic primitives
The final answer

The model learns the mapping from natural language and visual text to structured DSL code—specifically, it learns to recognize canonical problem schemas (proportional distribution, rate & percentage, change & revert, sum & split, difference analysis) and translate them into the corresponding DSL patterns. The fine-tuning also teaches the model the DSL grammar and the conventions for representing each type of relationship (e.g., multiplicative relations use repeated equal-length segments, transfers use paired solid/dashed segments).

Parameter-efficient comparison. The paper notes that this setup "enables parameter-efficient comparison with open-weight peers while treating proprietary models as upper bounds" (Section 5.1). This means that the comparison is fair at the architectural level (all open-weight models are fine-tuned on the same base architecture) and that proprietary models serve as aspirational targets rather than direct competitors (the 8B model would not be expected to match much larger proprietary models without the structured DSL training—and the fact that it exceeds them is the paper's key result).

No reinforcement learning or iterative self-improvement. Unlike approaches that use RL to optimize reasoning chains or that iteratively improve model outputs through self-play, TwD uses simple supervised fine-tuning on human-curated (or rather, LLM-generated and human-filtered) data. The paper does not explore whether additional training stages (RL fine-tuning, iterative refinement, or on-policy data collection) would further improve performance—though Appendix K indicates that an attempt with ReST $^{EM}$ (a self-improvement method) on a related revision task actually degraded performance, suggesting that the DSL generation task may be sensitive to training methodology.

Data Generation Pipeline for VisAlg

The paper constructs the VisAlg benchmark—the dataset that both trains and evaluates TwD—through a multi-stage pipeline that generates, refines, and filters DSL programs (Section 4.1, Figure 3).

Stage 1: Draft generation. The authors collect 15,000 bar-model word problems from public datasets and websites covering common visual algebra patterns. For each problem, they prompt Gemini-2.5-Pro (Comanici et al., 2025) to produce a synchronized draft with two components:

A textual analysis that explicitly parses the problem schema (entities, relations, constraints, query)
A DSL program that encodes this analysis using the Logic Graphic DSL

The prompt (provided in Appendix A.1, Figure 8) instructs the model to perform structured problem analysis, plan the diagram under strict bar-model constraints, and generate an executable DSL program. This stage establishes the logical and visual foundation for subsequent refinement.

Stage 2: Checklist-driven refinement. Initial drafts frequently fail to meet verifiability requirements because LLM-generated code is often syntactically incorrect or semantically inconsistent. The paper introduces a checklist refinement stage in which the model revisits each draft through three sequential checks:

Syntax check: ensuring the DSL grammar is correct and the program is executable (it will not crash the renderer).
Analysis check: verifying that all objects, quantities, relations, and targets identified in the textual analysis are consistently instantiated in the DSL—no missing entities and no phantom entities not mentioned in the analysis.
Style check: enforcing canonical bar-model layout conventions such as correct boundary placement, proper cross-row alignment, and consistent use of macros for common patterns.

The prompt for this stage (Appendix A.2, Figure 9) instructs the model to act as a verifier, checking each criterion and applying minimal, targeted corrections if any check fails. Critically, the model must determine whether the draft is product-ready—if it passes all checks, it is left unchanged; if not, only the failing criteria are corrected, preventing unnecessary changes that might introduce new errors.

Stage 3: Scoring and filtering. The refined drafts undergo an LLM-based scoring and filtering process. An LLM judge is calibrated against human expert evaluations: a domain expert scores 1,000 instances using a fixed rubric (covering geometric alignment, semantic completeness, representational compliance, and stylistic consistency), and the judge prompt is iteratively refined until it achieves 96% agreement with the human evaluator. The calibrated judge is then applied to the full set of 15,000 drafts, and only instances receiving a full score are retained.

The scoring rubric (detailed in Appendix A.4) enforces four categories:

Numerical validity: all bar-segment lengths must correspond to valid quantities in the correct solution process, without arbitrary scaling or distortion.
Information sufficiency: the rendered diagram alone, based on visible annotations, must be sufficient to solve the problem without consulting the original text—if a quantity is needed for the solution, it must appear on the diagram.
Alignment accuracy: all brackets and alignment markers must precisely coincide with valid segment boundaries—no floating or misaligned annotations.
Semantic fidelity: the diagram must correctly encode object relationships described in the natural language problem.

Additionally, five format compliance criteria must be satisfied: reduction encoding (solid-left and dashed-right segments for subtraction), transfer encoding (paired $-t/+t$ segments with equal magnitude across rows), multiplicative relations (repeated equal-length subsegments), non-abusive use of vertical operators, and semantically motivated decomposition.

The final filtering yields 11,372 product-ready instances—meaning that approximately 24.2% of the initial 15,000 drafts were discarded for failing one or more criteria. This high rejection rate illustrates the difficulty of generating structurally correct DSL programs even with a state-of-the-art model like Gemini-2.5-Pro, and it justifies the multi-stage pipeline design.

Stage 4: Splitting. The 11,372 instances are split into 10,430 training instances and 942 test instances, with the test set mirroring the training distribution in schema and difficulty (as shown in Table 1). Additional curated splits are created for fine-tuning, preference optimization, and evaluation, though the paper does not elaborate on how these additional splits differ.

Human expert validation. In addition to automated LLM-based verification, human experts screen all refined instances using a zero-tolerance evaluation (Appendix A.4). An instance is accepted only if it satisfies all five criteria (numerical validity, information sufficiency, alignment accuracy, semantic fidelity, and format compliance). Any instance failing any criterion is rejected. This dual filtering (LLM judge + human expert) ensures that the final dataset is of high quality, though the paper does not report the inter-annotator agreement statistics between the LLM judge and human experts beyond the initial 96% calibration figure.

Why this pipeline design matters for TwD's validity. The dataset construction pipeline is itself evidence for the paper's central claim. The fact that even Gemini-2.5-Pro—one of the most capable multimodal models available—requires multiple refinement stages and strict filtering to produce correct DSL programs demonstrates that DSL generation is a non-trivial reasoning task that standard LLMs struggle with. The pipeline's use of checklist-driven refinement and LLM-as-judge scoring mirrors the TwD paradigm at the data construction level: the system generates a draft, checks it against structural invariants, and refines it until it passes verification. This meta-level alignment between the data construction methodology and the model's inference-time behavior strengthens the paper's argument that verification-driven structured generation is the right approach for tasks requiring logical rigor.

4. Key Insights and Innovations

Innovation 1: Reconceptualizing Visual Reasoning as Optical Decompression—Parsing IS Reasoning

The paper's most fundamental intellectual move is not a new architecture or training method, but a reframing of what visual reasoning means. Prior work treats reasoning over visual inputs as a two-step pipeline: perceptual systems transcribe symbols from images (OCR, document understanding), then language models reason about those extracted symbols (Chain-of-Thought, Program-of-Thought). The paper argues this paradigm is categorically insufficient because it separates transcription from understanding—a model can faithfully extract the string "John has 3 times as many apples as Mary" without ever encoding the multiplicative topology that string implies.

The paper's reframing replaces this pipeline with a unified lens: optical decompression. If visual perception compresses logical structure into pixel tokens, then reasoning is the act of reconstructing that latent structure into an explicit, executable representation. This collapses the distinction between parsing and reasoning into a single claim: Parsing is Reasoning. You don't first parse then reason; the act of parsing the problem into a structured form is the reasoning process. The final answer is a "derivative of a verified logical structure" (Section 3.4), not an independently computed conclusion.

Why this is a fundamental reframing rather than an incremental improvement: it shifts the success criterion for visual reasoning from "did you get the right answer?" to "did you recover the correct logical topology?" Getting the right answer through flawed structural parsing (e.g., computing the correct number while misencoding a multiplicative relationship as additive) is, under this reframing, a failure—the model hasn't understood the problem, even if its arithmetic happened to work out. This is a higher bar than standard accuracy metrics, and it redefines what building trustworthy reasoning systems means.

The paper provides evidence for why this reframing matters through its error analysis (Appendix D). Figures 21-23 show baseline models producing outputs that are arithmetically compatible but topologically broken: a multiplicative constraint collapsed into an additive layout (Figure 21, "Semantic Erasure"), a computed value injected as a text label without geometric support (Figure 22, "Label Injection"), and incompatible alignment cues that break global boundary consistency (Figure 23, "Alignment Conflict"). These are not calculation errors—they are structural reasoning failures that would pass a surface-level accuracy check (the numbers might be right) but fail a topological verification check (the diagram doesn't encode the correct relationships). The paper's reframing makes these failures visible and diagnosable, where prior paradigms would obscure them.

This connects to the paper's contrast with Thinking with Images approaches (Su et al., 2025; Chern et al., 2025) in a non-obvious way. The critique isn't just that pixel-based generation is "imprecise"—it's that Thinking with Images operates in the wrong semantic space. A generated image encodes appearances, not constraints. Two bars may look proportional without being proportional in any verifiable sense. TwD's DSL encodes constraints that produce appearances deterministically—the diagram is a proof, not an illustration. This is a conceptual shift from "generation as creative output" to "generation as logical verification," and it reframes the entire role of visual generation in reasoning architectures.

The paper's results in Table 2 provide empirical validation for this reframing: the 8B TwD model achieves 82.63 overall score, surpassing Gemini-3-Pro (79.96) and Gemini-2.5-Pro (74.12). These proprietary models almost certainly have more parameters, more training compute, and stronger general reasoning capabilities. The fact that explicit structural supervision on a modest 8B model bridges and exceeds that gap suggests the reframing captures something that scale alone does not—the ability to enforce and verify structural invariants during reasoning.

Innovation 2: The Logic Graphic DSL as a Verifiable Intermediate Representation—Closing the Perception-Reasoning-Generation Loop

The paper introduces a new category of intermediate representation—the Logic Graphic DSL—that occupies a strategic niche not filled by any existing representation format. This isn't just "another DSL" in a field that already has many domain-specific languages for math, geometry, and programming. The DSL's distinctiveness lies in what it bridges and what it makes verifiable.

What it bridges. The DSL sits simultaneously at three interfaces:

Between natural language and formal logic: it converts ambiguous problem statements into precise geometric primitives with well-defined semantics (Entity primitives represent quantities, Relational primitives enforce equality, Aggregation primitives ground arithmetic in geometry).
Between code and visual rendering: it is executable—a DSL program deterministically renders into a diagram whose properties are provably correct relative to the encoded constraints. This is unlike general-purpose plotting code (Matplotlib, TikZ) where the mapping from code to visual properties is procedural and error-prone, and unlike Thinking with Images approaches where the pixel output is stochastic.
Between human and machine verification: the rendered diagram is a standard bar-model representation that human experts can evaluate at a glance and that automated checkers can verify programmatically against structural invariants. This dual verifiability is unavailable in purely textual reasoning (which requires human reading) or purely programmatic reasoning (which requires code inspection).

What distinguishes this from prior structured representations. Prior work on structured reasoning has used formal languages (e.g., Inter-GPS for geometry; Lu et al., 2021), executable code (Program-of-Thought; Chen et al.; PAL; Gao et al., 2023), and visual programming (ViperGPT; Surís et al., 2023). The paper's DSL differs in a critical way: it encodes visual topology, not just logical relations or computational steps. Python code can compute that $12 \times 124 = 1488$ ; it cannot encode that this multiplicative relationship is visually realized as 12 repeated equal-length unit segments aligned with a reference unit, making the proportionality visually deducible. The DSL makes the logical structure visible in the rendered output—you can see that the proportionality holds by inspecting the diagram—which is a fundamentally different standard of verifiability.

This is a fundamental advance in representation design rather than an incremental improvement, because it changes what "correct" means. In a code-based approach, correctness means "the program executes without errors and produces the right numeric answer." In TwD, correctness means "the DSL generates a diagram that satisfies all structural invariants (alignment, bracketing, proportionality encoding) AND the right answer follows from that verified structure." The paper's evaluation metrics reflect this: the composite score (Section 4.3) combines code similarity (chrF), image similarity (SSIM), and LLM-judge verification scores across five dimensions of structural correctness. A model can get the right answer and still score poorly if its DSL generates a topologically broken diagram—and the paper shows that this happens frequently with baseline models (Table 2, where Gemini-2.5-Pro scores only 74.97 on verification despite presumably high answer accuracy).

The deterministic rendering engine is the innovation's linchpin. The DSL would be an interesting but unverifiable notation without the renderer that guarantees exact geometric properties. The paper's Topological Abstraction layer (Section 3.3)—the virtual grid system and deterministic renderer—solves the "high-entropy coordinate" problem that would otherwise make DSL generation intractable. The model operates entirely in logical space (row IDs, relative lengths, alignment constraints), and the renderer handles metric computation. This decoupling is what makes it possible for an 8B model to generate correct DSL programs—the model does structural parsing, not geometry computation. The paper provides implicit evidence for this through its training setup: with only 2 epochs of supervised fine-tuning on 10,430 instances, the model learns to generate DSL programs that outperform much larger models. The simplicity of the training suggests the DSL design itself carries much of the cognitive load—it constrains the generation space to structurally valid outputs in a way that natural language or general-purpose code does not.

Innovation 3: A Diagnostic Taxonomy of Structural Degeneration—Making Reasoning Failures Visible and Classifiable

The paper contributes a diagnostic framework for understanding how and why multimodal models fail at rigorous visual reasoning. This is not a new method or metric—it is a conceptual tool for analyzing errors that the field previously lacked language to describe. The taxonomy (Section 5.5, Appendix D) identifies three categories of structural degeneration:

Semantic Erasure (Figure 21): a multiplicative constraint (e.g., "3× as many") is collapsed into an additive layout, erasing the repeated-unit structure that makes the proportionality visually provable. The diagram may support correct arithmetic (the numbers happen to work out) but it no longer encodes the logical relationship—the multiplier is reduced to a label rather than realized in topology.
Label Injection (Figure 22): a computed value is written as a text label without a corresponding geometric subsegment to support it. The diagram contains claims without evidence—downstream reasoning can treat the label as a quantity, but the visual structure doesn't justify it. This is a category error between annotation and representation.
Alignment Conflict (Figure 23): incompatible alignment cues (e.g., dashed completion implying one shared endpoint, vertical guides declaring another boundary) create global boundary inconsistency. The diagram asserts contradictory topological constraints, making the intended relationship unverifiable.

Why this taxonomy is intellectually distinctive. Prior work on reasoning errors in LLMs has largely focused on logical errors (incorrect deductions, missing steps, flawed arithmetic) or factual errors (hallucinations, incorrect knowledge). The paper's taxonomy identifies a third category: topological errors—failures to maintain global structural invariants under local transformations. These errors are invisible to standard accuracy metrics (a model can commit all three while still outputting the correct numeric answer for some problems) and invisible to standard chain-of-thought evaluation (the textual reasoning trace may appear coherent while the implied structure is inconsistent). They require a new evaluation lens—one that examines the structural fidelity of intermediate representations rather than just the correctness of final outputs.

This connects to the paper's broader claim about the precision paradox (Section 1) in a non-obvious way. The paradox states that perceptual systems achieve high-fidelity transcription while generative systems produce plausible-but-imprecise visualizations. The taxonomy shows that this paradox is not just a gap between input and output modalities—it manifests within the reasoning process itself. A model can produce a reasoning trace that is syntactically coherent, arithmetically compatible, and yet topologically degenerate. The taxonomy gives us language to describe this failure mode and criteria for detecting it.

Significance beyond raw performance. This is a diagnostic advance rather than a performance advance—it doesn't directly improve model accuracy, but it changes how we evaluate reasoning systems. The paper's evaluation framework (Section 4.3, Table 2) operationalizes this taxonomy through the five verification dimensions (structural alignment, information coverage, numerical consistency, semantic compliance, answer leakage). The strong correlation between these verification scores and human expert ratings (r = 0.9575, Figure 6) validates that the taxonomy captures genuine dimensions of reasoning quality that human evaluators care about. This makes the taxonomy actionable: other researchers can adopt these evaluation dimensions to assess structural reasoning quality in their own systems, even if they don't use the specific DSL or bar-model domain.

The set-theoretic reasoning generalization (Section 5.5, Figure 7) provides preliminary evidence that the taxonomy extends beyond bar models. The paper identifies a "calculation–construction gap" where models can perform correct arithmetic on set intersections but fail to preserve boolean containment and alignment constraints in the visual representation. This suggests that topological degeneration is not bar-model-specific—it is a general failure mode in any domain where reasoning must maintain global structural invariants under local operations.

Innovation 4: Evidence That Structured Supervision at Modest Scale Can Exceed Proprietary Frontier Models on Verifiable Reasoning

The paper provides a specific, quantified empirical finding that challenges assumptions about how reasoning capabilities scale: an 8B open-weight model with explicit structural supervision outperforms the strongest proprietary multimodal models (Gemini-3-Pro, Gemini-2.5-Pro, GPT-5.1) on a task requiring verifiable structural reasoning. This is not a claim that "small models can beat large models in general"—it is a more specific and interesting claim about what kind of training data and intermediate representation enables this inversion of the usual scaling hierarchy.

The headline numbers from Table 2 put this in concrete terms. TwD achieves 82.63 overall composite score. Gemini-3-Pro achieves 79.96. Gemini-2.5-Pro achieves 74.12. GPT-5.1 achieves 66.60. The gap between TwD and the strongest proprietary model is 2.67 points—modest in absolute terms, but remarkable given that TwD is built on Qwen3-VL-8B (which scores only 33.95 when evaluated without fine-tuning). The 48.68-point gain from fine-tuning (33.95 → 82.63) represents learning that is almost entirely about structural parsing—the base model already has visual perception and language understanding; what it lacks is the ability to translate those capabilities into verifiable DSL programs.

What makes this finding a genuine insight rather than just "fine-tuning helps." The comparison against proprietary models is not about raw intelligence—Gemini-3-Pro and GPT-5.1 almost certainly outperform Qwen3-VL-8B on nearly every standard benchmark. The finding is about the specific capability that explicit structural supervision unlocks and the inability of scale alone (even at frontier levels) to replicate that capability through general-purpose training. The paper argues, implicitly through its results and explicitly through its error analysis, that the proprietary models' lower scores stem from a specific deficit: they generate outputs that are arithmetically compatible but topologically inconsistent. They can compute the right numbers; they cannot maintain the structural invariants that make those numbers verifiable.

This is evidence for the paper's central axiom (Parsing is Reasoning) operating at the level of training methodology. If reasoning were just about computing correct answers from extracted symbols, the proprietary models would dominate—they have more parameters, more training compute, and likely more sophisticated reasoning capabilities. The fact that they don't dominate suggests that structural parsing is a distinct capability from general reasoning—one that requires explicit supervision on the intermediate representation format, not just more scale. The paper's claim that "this highlights the importance of explicit supervision on logic reconstruction for verifiable bar-model reasoning" (Section 5.2) is supported by the gap between Qwen3-VL-8B's base performance (33.95) and its fine-tuned performance (82.63)—a gain that cannot be attributed to improved general reasoning (the base model already had that) but to learning the specific skill of DSL construction.

Caveats that make this insight precise rather than overclaimed. The paper is careful to scope this finding. The DSL is domain-specific to bar-model visual algebra; the result does not claim that structured supervision generalizes to arbitrary reasoning tasks. The training data is generated by Gemini-2.5-Pro and filtered through a rigorous pipeline—the 8B model is effectively distilling structured reasoning capabilities from a larger model, not discovering them independently. The proprietary models are evaluated zero-shot (without fine-tuning on VisAlg), so the comparison is "fine-tuned 8B vs. zero-shot proprietary" rather than "8B vs. proprietary with equal training." These caveats don't diminish the finding's significance—they make it precise: structured supervision on a specific intermediate representation can, in a well-scoped domain, produce reasoning capabilities that exceed what general-purpose frontier models can achieve through scale and general training alone. This is a meaningful contribution to the ongoing debate about whether scale is sufficient for reasoning or whether architectural/representational innovations are necessary.

5. Experimental Analysis

Evaluation Methodology

Dataset. All experiments use VisAlg, a custom visual algebra benchmark constructed by the authors. The dataset comprises 15,000 initial bar-model word problems collected from public datasets and websites (Section 4.1), filtered through a multi-stage pipeline (generation by Gemini-2.5-Pro, checklist-driven refinement, LLM-judge scoring calibrated to 96% agreement with human experts, and human expert validation) to yield 11,372 product-ready instances. These are split into 10,430 training instances and 942 test instances (Table 1), with the test set mirroring the training distribution across five problem schemas (Proportional Distribution, Rate & Percentage, Change & Revert, Difference Analysis, Sum & Split) and three difficulty levels (Easy 13.4%, Medium 72.9%, Hard 13.7%).
Base model(s). The TwD model is initialized from Qwen3-VL-8B (Bai et al., 2025b), an open-weight multimodal large language model, and supervised fine-tuned on the VisAlg training split (Section 5.1). The choice of Qwen3-VL-8B is motivated by its status as a contemporary open-weight model with strong multimodal capabilities, enabling parameter-efficient comparison with other open-weight peers. For baselines, the paper evaluates five open-weight models (InternVL3-8B, InternVL2.5-8B, Intern-S1-mini, Mimo-VL-7B-RL, Qwen3-VL-8B) and five proprietary models (GPT-5.1, GPT-4o, Claude-4, Gemini-3-Pro, Gemini-2.5-Pro), all evaluated zero-shot on VisAlg (i.e., without fine-tuning on the VisAlg training data). The proprietary models represent "the current upper bound of general-purpose multimodal reasoning" (Section 5.1).
Metrics. The paper reports a composite score (Section 4.3) defined as:

$\text{Score} = \frac{1}{3}(\text{chrF} + \text{SSIM} + \text{LLM}_{\text{judge}})$

This combines three measurement dimensions: (1) Code similarity measured via BLEU, ROUGE-L, and chrF, with chrF as the primary metric due to its robustness to mixed symbols, numbers, and text in the DSL; (2) Image similarity measured via PSNR, SSIM, and LPIPS, with SSIM prioritized for its sensitivity to structural topology and edge continuity; (3) LLM-judge verification scores across five subjective dimensions—structural alignment, information coverage, numerical consistency, semantic compliance, and answer leakage—each rated in [0, 1] and averaged. The full evaluation produces separate reporting for each component metric (Table 2), with the composite Score serving as the main headline number. Additionally, Section 5.4 reports correlation between verifier-based VisAlg scores and human expert ratings (r = 0.9575, Figure 6).
Baselines. The paper evaluates ten baseline systems (Table 2, Section 5.1). Open-weight models (zero-shot): InternVL3-8B (Zhu et al., 2025), InternVL2.5-8B (Chen et al., 2024), Intern-S1-mini (Bai et al., 2025a), Mimo-VL-7B-RL (Li et al., 2025a), and Qwen3-VL-8B (Bai et al., 2025b). Proprietary models (zero-shot): GPT-5.1 (Achiam et al., 2023), GPT-4o (Hurst et al., 2024), Claude-4 (Anthropic, 2025), Gemini-3-Pro (Team et al., 2023), and Gemini-2.5-Pro (Comanici et al., 2025). The TwD model (fine-tuned Qwen3-VL-8B) is compared against all ten baselines. There are no task-specific baselines beyond zero-shot evaluation of existing models; the paper does not construct alternative fine-tuned baselines (e.g., fine-tuning a baseline model with standard Chain-of-Thought on the same training data but without DSL generation).
Generation budget / compute accounting. The paper does not use a generation budget in the sense of test-time compute scaling (no beam search, no best-of-N, no revision chains). Each model produces a single output per test instance—the DSL program, textual analysis, and final answer are generated in one or two sequential stages. The "compute" comparison is at the level of model scale and training methodology: TwD is an 8B parameter model fine-tuned on 10,430 training instances for 2 epochs (Section 5.1), compared against zero-shot proprietary models of unknown (but almost certainly much larger) scale. Training compute is characterized by hardware (8-GPU node) and hyperparameters (learning rate 5×10⁻⁶, warmup ratio 0.05, visual token cap 2,048, max sequence length 5,128), but total FLOPs are not reported. Inference-time compute is not varied or studied as an independent variable—the paper evaluates single-pass generation, not compute-scaled inference.
Cross-validation / statistical protocol. The paper does not employ cross-validation for model evaluation. The test set of 942 instances is fixed (Table 1), and all models are evaluated on this single split. For the data construction pipeline, the LLM judge used for filtering is calibrated against human expert evaluations: a domain expert scores 1,000 instances using a fixed rubric, and the judge prompt is iteratively refined until achieving 96% agreement with the human evaluator (Section 4.1). For human evaluation of model outputs (Section 5.4, Figure 6), three domain experts rate samples independently, with at least two reviewers per sample; disagreements spanning two or more score levels are resolved by a third reviewer via arbitration (Appendix B.2). The paper does not report confidence intervals, standard deviations, or statistical significance tests for any of the main results in Table 2 or the schema-wise breakdown in Figure 5.

Main Quantitative Results

Overall Performance on VisAlg (Table 2)

The TwD model achieves the highest overall composite score of 82.63, outperforming all ten baseline systems. The strongest proprietary model, Gemini-3-Pro, achieves 79.96—a gap of 2.67 points. The strongest proprietary model from the more recent generation, Gemini-2.5-Pro, achieves 74.12—a gap of 8.51 points. The base model from which TwD is initialized, Qwen3-VL-8B evaluated zero-shot, achieves only 33.95—a 48.68-point gain from fine-tuning (Table 2, "Overall" column).

Open-weight baseline performance. All open-weight models evaluated zero-shot score below 55 on the composite metric: InternVL3-8B achieves 54.99, InternVL2.5-8B achieves 48.70, Intern-S1-mini achieves 44.13, Mimo-VL-7B-RL achieves 37.78, and Qwen3-VL-8B achieves 33.95. The paper characterizes this as a "clear performance gap between open-weight and proprietary systems" (Section 5.2), noting that these models show "weaknesses in code fidelity and diagram reconstruction, indicating difficulty in generating syntactically valid and topologically consistent DSL programs without task-specific alignment."

Proprietary model performance. Among proprietary models, performance is tiered: Gemini-3-Pro leads at 79.96 (with the highest LLM-judge verification score of 91.98), followed by Gemini-2.5-Pro at 74.12, Claude-4 at 73.62, GPT-5.1 at 66.60, and GPT-4o at 60.11. The verification scores (LLM-judge average) reveal more dramatic gaps: Gemini-3-Pro scores 91.98 on verification while GPT-4o scores only 55.44. This suggests that even among frontier models, the ability to produce structurally verified DSL programs varies substantially—it is not a capability that comes "for free" with scale.

Component-level analysis. The paper breaks performance into code similarity, image similarity, and verification scores (Table 2). On code similarity, TwD achieves chrF of 68.29, substantially exceeding the best proprietary model (Gemini-2.5-Pro at 57.43) and dramatically exceeding all open-weight models (the highest being InternVL2.5-8B at 48.41). On image similarity (SSIM), TwD achieves 93.68, exceeding Gemini-3-Pro at 90.36 and well above all other models. On LLM-judge verification, TwD scores 85.91 (average across five dimensions), compared to 91.98 for Gemini-3-Pro, 74.97 for Gemini-2.5-Pro, and 61.69 for GPT-5.1.

A notable pattern in verification sub-scores. While TwD leads overall, Gemini-3-Pro achieves higher numerical consistency (0.94 vs. 0.70) and structural alignment (0.97 vs. 0.90). TwD's advantages are concentrated in information coverage (0.96 vs. 0.95) and, critically, answer leakage prevention (1.00 vs. 0.96), where a score of 1.00 indicates zero instances of the final answer appearing in quoted labels within the DSL. The paper notes that TwD's "remaining gap is mainly in numerical consistency, while structural legality and semantic completeness are largely preserved" (Section 5.2), suggesting that TwD's structural reasoning is sound but its arithmetic precision may trail the largest proprietary models on some instances.

The answer leakage dimension deserves attention. Across all models, answer leakage scores vary dramatically: GPT-5.1 scores 0.19 (suggesting 81% of its outputs leak the answer in labels), Gemini-2.5-Pro scores 0.32 (68% leakage), while Qwen3-VL-8B scores 1.00 (zero leakage) and TwD scores 1.00. For the proprietary models, high answer leakage is a specific failure mode: the model writes the computed answer as a text label in the diagram rather than marking the target as an unknown to be derived from the structure. This directly undermines the verifiability the DSL is designed to provide—if the answer is written explicitly, the diagram is no longer a proof of reasoning but merely a decorated answer key.

Schema-Wise Performance (Figure 5)

Figure 5 reports performance broken down by the five visual algebra problem schemas in VisAlg. The paper states that TwD "consistently achieve[s] competitive performance compared to both open-weight and proprietary baselines across all schemas" (Section 5.3), with gains "most pronounced on structure-intensive schemas such as proportional distribution and difference analysis, where accurate multi-segment decomposition and boundary-aligned comparison are critical."

While the paper describes the pattern qualitatively, the bar chart in Figure 5 (which the paper does not transcribe into numerical tables in the text) shows performance across schemas for TwD alongside multiple baselines. The paper's interpretation emphasizes that: (1) TwD remains "uniformly strong across problem types," supporting the claim that optical decompression benefits from explicit, verifiable logic regardless of the specific schema; (2) proprietary models "achieve competitive results" but their "performance varies noticeably across schemas," in contrast to TwD's uniformity; and (3) the largest gains for TwD relative to baselines appear on schemas requiring complex topological encoding (multiplicative relations in proportional distribution, comparative alignment in difference analysis) rather than on simpler schemas like sum & split.

The schema-wise analysis is limited in granularity. Figure 5 is a bar chart without accompanying numerical tables in the main text, making precise quantitative comparison difficult to extract. The paper does not report schema-wise results broken down by difficulty level, so it is unclear whether TwD's advantage holds uniformly across easy, medium, and hard instances within each schema, or whether the advantage is concentrated at particular difficulty levels. The paper also does not report whether specific schemas account disproportionately for the overall performance gap between TwD and proprietary models—for example, whether the gap on proportional distribution is substantially larger than on sum & split.

Generalization to Set-Theoretic Reasoning (Figure 7)

Section 5.5 extends evaluation beyond bar-model visual algebra to "advanced set-theoretic reasoning tasks involving multi-set constraints." The paper describes these tasks as requiring the model to "manage high-order intersections and nested boolean boundaries" (Figure 7). The figure shows a side-by-side comparison where frontier MLLMs like GPT-5 "exhibit topological hallucination"—while they "may attempt to align segments visually, they fail to preserve the strict boolean logic of overlaps," specifically failing to "distinctively ground intersections A∩C and A∩B∩C, violating containment and alignment constraints."

By contrast, TwD "successfully decomposes the abstract set problem into sequential geometric operations" and "explicitly render[s] the atomic intersections," effectively visualizing "the algebra of sets." The paper identifies this as evidence that the "calculation–construction gap" generalizes beyond bar models: "correct arithmetic does not guarantee preservation of global structural invariants such as boundary legality and consistency."

The generalization experiment is qualitative rather than quantitative. Figure 7 appears to show example outputs rather than aggregate metrics—the paper does not report scores, accuracy rates, or sample sizes for the set-theoretic reasoning extension. This makes the claim of generalization suggestive but not statistically grounded. The paper does not specify how many set-theoretic problems were evaluated, what the evaluation criteria were, or whether a formal benchmark was used. This is a significant limitation in the evidence for the claim that TwD's approach generalizes beyond the specific DSL and domain it was trained on.

Human-Expert Alignment (Figure 6)

Section 5.4 reports a strong Pearson correlation of r = 0.9575 between verifier-based VisAlg scores (the composite score from Section 4.3) and human expert ratings. The paper states that "model rankings are largely preserved across the full performance range" and that TwD "remains top-ranked under both evaluations, indicating that the reported gains reflect genuine improvements in structural correctness rather than metric artifacts."

The human evaluation protocol (Appendix B) is rigorous: three domain experts with backgrounds in mathematics education and diagram-oriented coding rate each sample independently; at least two reviewers evaluate each sample; disagreements spanning two or more score levels trigger third-reviewer arbitration; and each rating must be accompanied by "minimal sufficient evidence" directly verifiable from the DSL output. The evaluation covers five dimensions (structural alignment, information coverage, numerical consistency, semantic conformity, answer leakage) mapped to a five-level overall scale.

This is a strong validity check for the automated metrics. The high correlation between automated LLM-judge scores and human expert ratings validates that the composite metric captures dimensions of reasoning quality that humans care about, not just superficial code or image similarity. However, the paper does not report what the human ratings actually were for each model (only the correlation), so we cannot assess whether the absolute human judgment scores align with the automated scores in magnitude or only in relative ranking.

Ablation Studies and Robustness Checks

The paper does not present formal ablation studies in the traditional sense—there is no component-by-component removal analysis, no hyperparameter sensitivity sweep, no training data size scaling experiment, and no comparison of the two-stage TwD process against a one-stage variant that generates the DSL and answer without the verification drafting loop. The evaluation is primarily a model comparison between TwD and baseline systems evaluated zero-shot.

Data quality ablation (implicit via pipeline design). The dataset construction pipeline (Section 4.1) implicitly serves as a data quality ablation: 15,000 initial Gemini-2.5-Pro-generated drafts are filtered to 11,372 product-ready instances after checklist-driven refinement, LLM-judge scoring, and human expert validation. The ~24% rejection rate demonstrates that even state-of-the-art models produce structurally incorrect DSL programs frequently. However, TwD is trained only on the filtered data—the paper does not report what performance would be if trained on unfiltered or partially filtered data. This leaves open the question of whether the filtering is necessary for the observed performance or whether the model could learn to be robust to noisy training examples.

Base model ablation (implicit via zero-shot evaluation). The zero-shot evaluation of Qwen3-VL-8B (score 33.95) versus its fine-tuned TwD counterpart (82.63) serves as a de facto ablation of fine-tuning. The 48.68-point gain isolates the effect of supervised fine-tuning on the VisAlg training data, but it conflates two factors: learning to generate DSL code at all, and learning the specific structural conventions of the bar-model DSL. The paper does not disentangle these by, for example, fine-tuning on a generic code generation task or on an alternative DSL to measure transfer.

Proprietary model scaling as weak ablation. The comparison between proprietary models of different generations (GPT-4o → GPT-5.1, Gemini-2.5-Pro → Gemini-3-Pro) can be read as a weak scaling ablation: larger/more recent models perform better (Gemini-3-Pro at 79.96 vs. Gemini-2.5-Pro at 74.12; GPT-5.1 at 66.60 vs. GPT-4o at 60.11), but none reach TwD's performance despite likely being much larger. However, this is confounded by differences in training data, architecture, and post-training—these are different model families at different scales, not controlled scaling of a single architecture.

Missing ablations that would strengthen the paper. The paper would benefit from several straightforward experiments: (1) Training TwD on the unfiltered 15,000 drafts to measure the value of data filtering; (2) Evaluating a variant of TwD that generates the DSL and answer in a single stage without the verification drafting loop to isolate the contribution of the two-stage process; (3) Fine-tuning one or more baseline open-weight models (e.g., InternVL3-8B) on the same VisAlg training data to determine whether the gains are specific to the DSL or achievable by any model fine-tuned on this data distribution; (4) Training TwD with Chain-of-Thought or Program-of-Thought supervision instead of DSL supervision as a controlled comparison of representation formats; (5) Reporting performance at different training data sizes (1k, 5k, full 10,430) to assess data efficiency.

Critical Assessment

Claim 1: TwD outperforms frontier proprietary models on visual algebra reasoning.

Supported with significant caveats about the comparison.

The headline result—TwD (82.63) exceeds Gemini-3-Pro (79.96) and all other proprietary models—is clearly demonstrated in Table 2. However, the comparison is between a fine-tuned model (TwD, trained on 10,430 in-distribution examples) and zero-shot proprietary models (which have never seen VisAlg training data or the specific DSL format). This is not a controlled experiment—it compares "specialized system with domain training" against "general-purpose system without domain training." The paper is transparent that proprietary models are evaluated zero-shot and serve as "upper bounds" (Section 5.1), but the framing in the abstract and conclusion ("outperforms leading proprietary frontiers") could be read as implying a like-for-like comparison when it is not.

What the experiment demonstrates is narrower: that explicit supervision on DSL generation for bar-model problems produces better structural reasoning on those problems than general-purpose multimodal reasoning without such supervision—even when the general-purpose models are much larger. This is a valid and interesting finding, but it is about the value of domain-specific structured supervision, not about TwD being a "better model" in any general sense. A fairer comparison would fine-tune a proprietary model on the same training data and evaluate whether the gain persists, or conversely, evaluate TwD zero-shot on VisAlg (without fine-tuning the base model—which we know scores 33.95, far below proprietary models). This missing comparison means we cannot distinguish between "the DSL is a better reasoning format" and "fine-tuning on in-distribution data is powerful"—both are likely true, but their relative contributions are unknown.

Claim 2: The Logic Graphic DSL serves as a cognitive scaffold that enables verifiable reasoning.

Supported by the component-level results but not by controlled ablation.

The paper's evidence for this claim comes from the gap between open-weight and proprietary models in Table 2: open-weight models "show weaknesses in code fidelity and diagram reconstruction, indicating difficulty in generating syntactically valid and topologically consistent DSL programs without task-specific alignment" (Section 5.2). The large gap between Qwen3-VL-8B zero-shot (33.95) and fine-tuned (82.63) shows that DSL generation is not a capability that emerges from general multimodal pretraining—it requires explicit training.

However, the paper never demonstrates that the DSL causes better reasoning as opposed to merely correlating with it through fine-tuning. A critical missing experiment: train a model with standard Chain-of-Thought supervision (text-only reasoning traces) on the same set of 10,430 problems, evaluate answer accuracy, and compare against the DSL-supervised model. If the DSL-supervised model achieves higher answer accuracy (not just higher structural fidelity scores), that would support the claim that the DSL improves reasoning. If both achieve similar answer accuracy but only the DSL model produces verified diagrams, the claim would need to be qualified: the DSL provides verifiability but not necessarily improved reasoning. The paper's metrics heavily weight structural fidelity (chrF, SSIM, LLM-judge on structural dimensions), so the composite score advantage could partly reflect the model being optimized for the evaluation criteria rather than genuinely better at solving problems.

The answer leakage scores provide indirect evidence: proprietary models show high leakage (GPT-5.1 at 0.19, Gemini-2.5-Pro at 0.32), meaning they often write the answer directly into the diagram rather than encoding the structure that produces it. This suggests that even when these models get the right answer, they do not construct structurally sound DSL programs—the diagram is a decorated answer key, not a reasoning proof. However, knowing that proprietary models' DSLs are structurally flawed does not tell us whether their answers are more or less accurate than TwD's—the paper does not report pure answer accuracy as a separate metric, so we cannot assess whether structural fidelity trades off against computational correctness.

Claim 3: The precision paradox (high-fidelity perception + imprecise generation = failed logical reasoning) is addressed by optical decompression.

Supported qualitatively through error analysis but not quantitatively linked to the main results.

The error analysis in Appendix D (Figures 21-23) provides compelling illustrations of structural degeneration: Semantic Erasure (multiplicative constraint collapsed to additive), Label Injection (computed value without geometric support), and Alignment Conflict (incompatible global boundaries). These are genuinely insightful diagnoses of failure modes that standard metrics would miss.

However, the paper does not quantify how frequently these failure modes occur across models or whether TwD eliminates them. We see representative examples of baseline failures, but not aggregate statistics: what fraction of Gemini-2.5-Pro outputs exhibit Semantic Erasure? What fraction of GPT-5.1 outputs exhibit Label Injection? Without such statistics, the taxonomy remains a qualitative contribution—valuable for understanding failure modes, but insufficient to claim that TwD systematically addresses them. The verification scores in Table 2 (structural alignment, numerical consistency, etc.) partly quantify these dimensions, but they are summary scores that don't map cleanly onto the specific taxonomy categories. For instance, a low structural alignment score could reflect Semantic Erasure, Alignment Conflict, or other issues—the taxonomy provides names for failure modes but the evaluation doesn't separately report their prevalence.

The set-theoretic generalization experiment (Figure 7) provides a case study of the calculation–construction gap, but this is a single example rather than a systematic evaluation. The paper claims that frontier models exhibit "topological hallucination" in set-theoretic reasoning, but we don't know whether this is universal (happens in most instances of this task type) or cherry-picked (a striking failure case selected to illustrate the phenomenon). Quantitative generalization results—even on a modest set of 50-100 set-theoretic problems with reported accuracy and structural fidelity metrics—would substantially strengthen this claim.

Claim 4: The 8B model with TwD achieves this performance through structured supervision, not scale.

Supported by the gap between base and fine-tuned performance, but the supervision source is partially circular.

The paper trains TwD on DSL programs generated by Gemini-2.5-Pro and refined through a rigorous pipeline. This means the 8B model is effectively being trained to replicate the structured reasoning outputs of a much larger model—a form of distillation. The finding that TwD then outperforms Gemini-2.5-Pro (74.12 vs. 82.63) is initially paradoxical: how can a student outperform its teacher on the same task?

The paper's explanation—implicit in the data pipeline description—is that the filtering and refinement process improves upon Gemini-2.5-Pro's raw outputs, so the training data is higher quality than what Gemini-2.5-Pro would produce zero-shot. The 24% rejection rate supports this: approximately one in four of Gemini-2.5-Pro's drafts fail the quality checks, and those are excluded from training. TwD learns from a curated subset of the best outputs plus human-expert corrections, effectively distilling a higher-quality signal than Gemini-2.5-Pro's raw distribution.

This complicates the "structured supervision not scale" narrative. The structured supervision itself comes from a large model (Gemini-2.5-Pro) augmented with human expertise and automated checking. The 8B model's advantage may reflect the quality of this curated training signal rather than an inherent superiority of the TwD paradigm. A cleaner test would be: can a model trained entirely on human-constructed DSL programs (no large model involved in data generation) achieve similar performance? Or conversely: if we give Gemini-2.5-Pro the same data refinement pipeline (i.e., let it do multi-stage self-refinement at inference time), does it close the gap? Neither experiment is conducted.

Structural weaknesses in the experimental design.

Single benchmark, single domain. All quantitative results are on VisAlg, a custom benchmark in one specific domain (bar-model visual algebra). The paper acknowledges this in its Limitations section but does not mitigate it with any out-of-domain evaluation beyond the qualitative set-theoretic example. This is a significant constraint on the generality of the findings: we cannot assess whether TwD's approach transfers to geometry problems, physics diagrams, chemical structures, or any other visual reasoning domain.

No answer accuracy metric. The composite score weights code similarity, image similarity, and verification scores—all of which measure structural fidelity of the DSL output. The paper does not report pure answer accuracy (what fraction of problems does each model solve correctly?). This is a critical omission because it makes the structural fidelity / computational correctness tradeoff invisible. A model could achieve a high composite score by producing structurally perfect DSL programs that encode incorrect arithmetic (e.g., correct topology with wrong segment lengths), or conversely, a model could have high answer accuracy but low composite score because its DSL syntax is non-standard. Without answer accuracy, we cannot assess whether structural fidelity is necessary, sufficient, or merely correlated with correct problem solving.

Zero-shot baseline conflates format unfamiliarity with reasoning inability. The proprietary models are evaluated zero-shot on a task that requires generating code in a custom DSL they have never seen. Their lower scores could reflect unfamiliarity with the DSL syntax and conventions rather than inability to reason about bar-model problems. The paper partially addresses this through the LLM-judge verification scores (which assess structural properties of the output regardless of whether the model "intended" to follow DSL conventions), but a baseline that gives proprietary models few-shot examples or a DSL specification in the prompt would strengthen the claim that their lower scores reflect reasoning limitations rather than format unfamiliarity.

No statistical significance reporting. The paper reports point estimates (means) for all metrics without confidence intervals, standard deviations, or statistical tests. With a test set of 942 instances, the standard error on a proportion metric (e.g., accuracy) is approximately 1.6 percentage points. The gap between TwD (82.63) and Gemini-3-Pro (79.96) is 2.67 points—likely statistically significant, but not certainly so without variance estimates. The schema-wise results (Figure 5) and difficulty breakdowns would have even larger standard errors due to smaller sub-sample sizes.

No latency or inference cost analysis. TwD's two-stage generation process (generate draft → render → condition on rendered draft → generate final answer) presumably takes more wall-clock time than single-pass generation by proprietary models. The paper does not report inference latency, token counts, or computational cost for any model. This matters for practical deployment claims—if TwD takes 10× longer per query than Gemini-3-Pro, the accuracy advantage needs to be weighed against latency. The paper frames itself as offering a paradigm for trustworthy reasoning but does not characterize the computational overhead of that trustworthiness.

Dataset contamination risk from Gemini-2.5-Pro. The training data is generated by Gemini-2.5-Pro and refined. When evaluating Gemini-2.5-Pro itself on the test set, there is a risk that the model's zero-shot outputs are drawn from a similar distribution as its training-data-generation outputs, potentially inflating its score relative to models that had no role in data creation. The paper does not discuss or mitigate this risk.

6. Limitations and Trade-offs

The DSL Is Scoped Exclusively to Bar-Model Visual Algebra — No Evidence of Generalization to Other Diagram Types

The assumption or constraint. The Logic Graphic DSL is designed around the specific topological constraints of bar-model visual algebra: horizontal bars represent quantities, vertical alignment markers encode equality, and aggregation braces represent arithmetic operations. The paper is transparent about this scoping:

"The core limitation lies in the scope of structural representation: the DSL is intentionally designed around bar-model visual algebra, emphasizing linear topological relations to enable intuitive structural supervision. Extending this DSL to support broader classes of scientific diagrams remains an important direction for future research." (Limitations section)

The DSL's primitives (Entity HL, Relational VL, Aggregation HB/VB) assume that all quantities can be represented as horizontal bars, all logical relationships as vertical alignment, and all arithmetic as brace annotations. These assumptions hold for bar-model problems but break immediately for other visual reasoning domains: geometry proofs require angular and distance relations, physics diagrams require force vectors and trajectories, chemical structures require bond types and spatial conformations, and general scientific diagrams may involve nested containment, directed graphs, or temporal sequences. None of these are representable in the current DSL without fundamental extensions to the primitive set.

The consequence. The paper provides no quantitative evidence that the TwD paradigm—structured DSL generation as verifiable intermediate representation—transfers to any domain beyond bar models. The set-theoretic reasoning generalization experiment (Section 5.5, Figure 7) shows a single qualitative example and is not a systematic evaluation. A practitioner considering TwD for geometry tutoring, physics problem solving, or general diagram understanding has no data to assess whether the approach works, fails gracefully, or produces actively misleading outputs in their domain. The DSL would need to be redesigned from scratch for each new diagram type, and there is no evidence that the training pipeline (LLM-generated drafts, checklist-driven refinement, LLM-judge filtering calibrated to 96% human agreement) produces comparable data quality when the topological constraints are more complex than linear alignment and bracketing.

What evidence exists in the paper. Essentially none beyond the qualitative set-theoretic example. The paper evaluates on VisAlg, a bar-model-specific benchmark, and does not report results on any out-of-domain visual reasoning dataset (e.g., geometry problem solving like GeoQA or Geometry3K, diagram understanding like AI2D, or physics problem solving). The set-theoretic extension (Figure 7) is described as preliminary and is not quantified. The paper's contributions are strong within their scope but the scope is narrow, and the paper does not provide a roadmap for DSL design in new domains beyond stating that extension is future work.

Mitigation status. Not addressed. The paper acknowledges the limitation explicitly and frames extension to broader diagram classes as future work, but makes no attempt to characterize what properties a domain must have for the DSL approach to be applicable, what the DSL design process would entail for a new domain, or what level of effort would be required (e.g., how many training examples, how many refinement iterations).

Answer Accuracy Is Not Reported — Structural Fidelity and Computational Correctness Are Conflated

The assumption or constraint. The paper's evaluation framework measures structural fidelity of the generated DSL programs—code similarity (chrF), image similarity (SSIM), and LLM-judge verification scores (structural alignment, information coverage, numerical consistency, semantic compliance, answer leakage)—but never reports whether the final numeric answer is correct. The composite score weights these structural metrics equally:

$\text{Score} = \frac{1}{3}(\text{chrF} + \text{SSIM} + \text{LLM}_{\text{judge}})$

where chrF measures how closely the generated DSL code matches the ground-truth DSL, SSIM measures how similar the rendered diagram is to the reference diagram, and LLM-judge measures structural properties of the output. Accuracy—the fraction of problems for which the model's final answer matches the ground-truth answer—is never reported for any model.

The consequence. The paper cannot distinguish between two fundamentally different types of errors: (1) structurally correct DSL programs that encode incorrect arithmetic (the topology is right but segment lengths or computed quantities are wrong), and (2) structurally broken DSL programs that nonetheless produce correct numeric answers (the model gets lucky or computes the answer through a non-DSL reasoning path). The first type would achieve high composite scores (good structural fidelity) but low accuracy—a failure mode the evaluation framework would miss entirely. The second type would achieve low composite scores but high accuracy—a capability the evaluation framework would penalize unfairly.

This matters practically because a system that generates beautiful, topologically perfect diagrams with wrong answers is worse than useless—it provides false confidence in incorrect reasoning. Conversely, a system that gets the right answer through imperfect DSL construction might still be valuable for downstream tasks where only the answer matters. Without answer accuracy, a practitioner cannot assess whether the improved structural fidelity that TwD provides translates into better problem-solving outcomes, or whether it represents an orthogonal quality dimension that may trade off against computational correctness.

The paper's error analysis (Appendix D) provides anecdotal evidence that baseline models sometimes produce correct answers from topologically broken diagrams, but the prevalence of this phenomenon is unmeasured. The verification sub-scores provide indirect evidence: TwD achieves 0.70 numerical consistency vs. Gemini-3-Pro's 0.94 (Table 2), suggesting TwD may make more arithmetic errors despite having better overall structural fidelity. Without accuracy, we don't know which model actually solves more problems correctly.

What evidence exists in the paper. The VisAlg benchmark includes ground-truth answers for every test instance (Section 4.1), so computing accuracy would require only comparing the model's output answer against the ground truth—a trivial evaluation that the paper omits. The LLM-judge's numerical consistency dimension (Section 4.3) evaluates whether segment lengths satisfy intended arithmetic constraints, but this is a property of the DSL representation, not a measure of whether the final answer matches the ground truth. A model could have perfect numerical consistency (all segment lengths satisfy their intended constraints) while still producing the wrong final answer if the constraints it encodes are semantically incorrect.

Mitigation status. Not addressed. The paper acknowledges that accuracy is relevant—the LLM-judge includes answer leakage as an evaluation dimension—but never reports it as an outcome metric. The composite score's weighting scheme (1/3 each for code, image, and verification) implicitly values structural fidelity and computational correctness as equally important contributions to overall quality, but without separate reporting of each, the tradeoff between them is invisible.

The 24% Data Rejection Rate Masks How Hard DSL Generation Is — TwD Benefits from Training on Curated Data That Its Teacher Model Could Not Produce Reliably

The assumption or constraint. The VisAlg training data is generated through a multi-stage pipeline: Gemini-2.5-Pro produces initial DSL drafts from 15,000 bar-model problems, these drafts undergo checklist-driven refinement, then LLM-judge scoring (calibrated to 96% human agreement), and finally human expert validation. The result is 11,372 product-ready instances—meaning approximately 24.2% of the initial 15,000 drafts were discarded for failing one or more of the quality criteria (Section 4.1). The TwD model is trained exclusively on the filtered, high-quality subset.

The consequence. The 8B TwD model is trained on data that is substantially higher quality than what Gemini-2.5-Pro—or any model—can produce in a single pass. The training signal is effectively a distilled, corrected version of Gemini-2.5-Pro's outputs, augmented by automated and human verification. This means TwD's reported advantage over Gemini-2.5-Pro (82.63 vs. 74.12) and other proprietary models confounds two factors: (1) the effectiveness of the TwD paradigm (DSL generation + verification drafting), and (2) the quality of the curated training data. The model may be succeeding because it was trained on better data, not because the two-stage verification process at inference time adds value over single-pass generation.

More critically, the 24% rejection rate reveals that DSL generation is intrinsically difficult—even for a frontier model like Gemini-2.5-Pro, one in four drafts is structurally invalid. This has implications for deployment: if a user presents a novel bar-model problem that differs from the training distribution, the model's DSL output may contain structural errors that the training data does not teach it to avoid (because the training data was filtered to exclude such errors). The model learns from examples of correct DSL programs but never sees examples of errors and their corrections, potentially leaving it unable to recover from its own mistakes at inference time.

What evidence exists in the paper. The rejection rate (24.2%) is reported in Section 4.1, and the paper describes the data pipeline in detail (Appendix A). However, the paper never evaluates TwD on unfiltered training data to measure the importance of data quality, never reports how often TwD produces structurally invalid DSL outputs at inference time (the verification scores in Table 2 are aggregate quality measures, not validity rates), and never compares TwD's single-pass DSL generation quality against Gemini-2.5-Pro's single-pass quality to isolate the effect of training data vs. model architecture.

Mitigation status. Not addressed. The paper presents the data pipeline as a methodological contribution but does not analyze its impact on final model performance through ablation. The implicit assumption is that high-quality training data is necessary and the pipeline is the means to obtain it—but whether alternative approaches (e.g., training on noisier data with a different loss function, or using reinforcement learning to optimize DSL validity) would achieve similar or better results is unexplored.

Comparison Against Zero-Shot Proprietary Models Is Not Controlled — We Cannot Disentangle Structured Supervision from In-Distribution Training

The assumption or constraint. All proprietary models (Gemini-3-Pro, Gemini-2.5-Pro, GPT-5.1, GPT-4o, Claude-4) are evaluated zero-shot on VisAlg—they are given the test problems with instructions to produce DSL programs but receive no training on the VisAlg data distribution, no few-shot examples, and no exposure to the specific DSL grammar beyond what is described in the prompt. TwD, in contrast, is fine-tuned on 10,430 VisAlg training instances for 2 epochs. The paper acknowledges this asymmetry: proprietary models serve as "upper bounds of general-purpose multimodal reasoning" (Section 5.1), not as directly comparable systems.

The consequence. The headline finding—"a compact 8B model... outperforms leading proprietary frontiers"—is true as stated but potentially misleading about what causes the performance gap. The comparison tests "specialized system with in-distribution training" against "general-purpose system without in-distribution training." Any specialized system trained on 10,430 in-distribution examples would be expected to outperform a general-purpose system on that distribution—this is not a surprising result, regardless of what the specialized system does. The interesting question is not whether fine-tuning helps (it obviously does—Qwen3-VL-8B goes from 33.95 to 82.63), but whether the DSL-structured supervision + two-stage verification process produces better outcomes than alternative fine-tuning approaches that use the same training data but different output formats.

Critical missing comparisons: (1) Fine-tune a baseline open-weight model with standard Chain-of-Thought supervision (text-only reasoning to answer) on the same 10,430 problems and compare answer accuracy. If TwD's answer accuracy exceeds this baseline, the DSL adds value beyond in-distribution training. If not, the structural fidelity gains come at no cost to accuracy but also provide no accuracy benefit—they improve verifiability without improving correctness. (2) Fine-tune a proprietary model or a larger open-weight model on the same data to establish whether the 8B scale is necessary or whether larger models benefit equally. (3) Provide proprietary models with few-shot examples or the DSL specification in the prompt to reduce the format unfamiliarity confound. None of these comparisons are conducted.

The paper's framing "outperforms leading proprietary frontiers" (Section 6) also ignores that the proprietary models almost certainly outperform TwD on nearly every standard multimodal benchmark—the claim is true only on this specific, in-distribution task. Without cross-benchmark evaluation, the reader cannot gauge whether TwD's advantage is narrow (specific to bar-model DSL generation) or indicative of a broader reasoning capability.

What evidence exists in the paper. Table 2 and Figure 5 report all model comparisons. The zero-shot baseline for Qwen3-VL-8B (33.95) provides a lower bound on what the base model achieves without fine-tuning. The gap between base Qwen3-VL-8B and fine-tuned TwD (48.68 points) establishes that fine-tuning is the dominant factor. The gap between TwD and proprietary models (2.67-22.52 points, depending on the model) is substantially smaller than the fine-tuning gain, suggesting that in-distribution training—rather than DSL architecture specifically—may account for much of TwD's advantage.

Mitigation status. The paper acknowledges that proprietary models are evaluated zero-shot and serve as upper bounds (Section 5.1), but does not discuss how this methodological choice affects the interpretation of results. The conclusion (Section 6) states that TwD "outperforms leading proprietary frontiers on visual algebra problems" without the qualification that this comparison is between fine-tuned and zero-shot systems. The paper would be strengthened by either conducting controlled comparisons or explicitly framing the finding as evidence for the value of domain-specific structured supervision rather than evidence of model superiority.

The Two-Stage Verification Loop Is Not Ablated — We Cannot Determine Whether the Rendering-Feedback Stage Adds Value Over Single-Pass DSL Generation

The assumption or constraint. TwD is defined as a two-stage process: Stage 1 generates an initial DSL draft and renders it as a verification image, Stage 2 conditions on this rendered image to produce a refined DSL and final answer (Section 3.4). The paper presents this as central to the paradigm:

"The TwD paradigm thus posits that the act of constructing the draft is the reasoning engine itself, ensuring the final answer is a derivative of a verified logical structure." (Section 3.4)

The assumption is that seeing the rendered diagram enables the model to detect and correct structural errors that it would otherwise miss—the visual proof provides feedback that improves the final output.

The consequence. Without an ablation comparing two-stage TwD against single-stage TwD (generating the final DSL and answer in one pass without intermediate rendering), we cannot determine whether the verification loop adds value or merely adds latency. Several alternative hypotheses are consistent with the reported results:

Hypothesis A (the paper's claim): The rendering-feedback loop enables the model to detect topological errors in its initial draft and correct them in Stage 2, producing structurally better outputs than single-pass generation.
Hypothesis B (null hypothesis): The two-stage process provides no benefit over single-pass generation with the same total compute budget. The model learns during fine-tuning to produce correct DSL programs; the intermediate rendering is decorative rather than functional.
Hypothesis C (training artifact): The two-stage process is useful because the training data was constructed through a refinement pipeline (Section 4.1), so the model learns to emulate refinement behavior. However, a model trained on single-pass data (no refinement traces) might achieve similar final quality with lower latency.

The practical consequence is significant: if Hypothesis B or C is true, the two-stage process imposes unnecessary latency (rendering the diagram and feeding it back as input) without improving output quality. A deployment system could simply generate the DSL and answer in one pass, halving inference time. If Hypothesis A is true, the latency is a necessary cost for structural correctness. Without the ablation, practitioners cannot make this engineering decision.

What evidence exists in the paper. The paper describes the two-stage architecture in Section 3.4 and presents it as integral to TwD, but provides no experimental comparison against a one-stage variant. The schema-wise results (Figure 5) and main results (Table 2) are for the full two-stage system only. The error analysis (Appendix D) shows baseline models making topological errors that TwD avoids, but this compares TwD against zero-shot baselines, not TwD against a one-stage version of itself—the comparison cannot isolate the contribution of the verification loop specifically.

Mitigation status. Not addressed. The paper makes no mention of single-stage ablation, does not report whether the two-stage process produces measurably different outputs than a hypothetical one-stage process, and does not characterize the computational cost of the rendering-feedback step. The paper's framing presents the two-stage architecture as definitional to TwD, implying that removing it would produce a different paradigm, but the empirical justification for its necessity is absent.

Difficulty Estimation and Error Recovery Are Not Mechanized — The System Has No Way to Detect or Correct Its Own Failures at Inference Time

The assumption or constraint. TwD generates a DSL draft, renders it, and conditions on the rendering to produce a final answer. However, the model has no explicit mechanism for detecting when its DSL draft is structurally invalid and no recovery strategy beyond the fixed two-stage pipeline. If Stage 1 produces a topologically broken draft (e.g., misaligned vertical markers, semantically erased multiplicative constraints, injected labels without geometric support—the failure modes documented in Appendix D), Stage 2 receives a broken verification image. The model may or may not detect the error; if it doesn't, it produces an answer derived from a faulty structure. If it does detect the error, the paper provides no mechanism for iterating—the two-stage process is fixed, with no option to retry Stage 1 or request human intervention.

The VisAlg benchmark spans three difficulty levels (Table 1): Easy (13.4%), Medium (72.9%), and Hard (13.7%). The paper reports aggregate metrics but does not report performance stratified by difficulty. We do not know whether TwD's 82.63 composite score reflects near-perfect performance on easy problems, good performance on medium problems, and complete failure on hard problems—or uniform performance across all difficulties. The training data filtering (24% rejection rate) means the hardest problems—those where Gemini-2.5-Pro most frequently produced invalid DSL—are likely underrepresented in the training set, potentially creating a capability cliff where TwD performs well on problems similar to the training distribution and degrades rapidly on novel or combinatorially complex problems.

The consequence. In deployment, TwD has no safeguards against producing confident but structurally wrong outputs. The system will render a broken diagram and derive an answer from it without any mechanism to flag uncertainty, request clarification, or trigger a retry with different parameters. This is fundamentally at odds with the paper's stated motivation of "trustworthy multimodal intelligence" (Section 6)—a system that cannot detect its own failures is not trustworthy, even if its structural fidelity scores are high on average. A practitioner deploying TwD for educational applications (the domain the paper targets) would need to know the failure rate on hard problems and have a strategy for handling failures gracefully, but the paper provides neither the statistics nor the mechanism.

The paper's own error taxonomy (Appendix D) identifies three categories of structural degeneration (Semantic Erasure, Label Injection, Alignment Conflict) that baseline models exhibit. Without difficulty-stratified evaluation, we cannot assess whether TwD eliminates these failure modes or merely reduces their frequency on easy-to-medium problems while still failing on the hardest instances.

What evidence exists in the paper. The paper reports difficulty composition of VisAlg (Table 1, Figure 4) but does not report model performance by difficulty. The verification sub-scores (Table 2) provide aggregate quality measures across all 942 test instances, but these averages may hide substantial variance across difficulty levels. The human evaluation (Section 5.4, Figure 6) correlates verifier scores with human expert ratings but does not break this correlation down by difficulty. The paper acknowledges the verification loop conceptually (Section 3.4 describes the two-stage process as enabling self-inspection) but never evaluates whether self-inspection actually works—whether errors introduced in Stage 1 are corrected in Stage 2, and at what rate.

Mitigation status. Not addressed. The paper neither reports difficulty-stratified results nor proposes mechanisms for failure detection and recovery. The two-stage architecture is presented as sufficient for verification, but verification (detecting that a structure is correct after rendering) is different from error correction (detecting that a structure is wrong and fixing it). The paper conflates these under the concept of optical decompression but provides no evidence that the system can recover from its own structural errors at inference time.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a diagnostic reframing of multimodal visual reasoning, not a paradigm shift in model architecture or training methodology. Its impact lies in changing what we measure and what we consider correct rather than how models process information. This is a more modest but potentially more durable contribution than a new architecture would be—diagnostic frameworks persist even as architectures change.

The reframing is specific: "Parsing is Reasoning." The paper argues that for tasks requiring rigorous logical consistency, the act of translating perceptually extracted symbols into a structured, executable representation constitutes understanding—it is not a precursor to reasoning, it is reasoning itself. This collapses a distinction that the field has largely taken for granted: that perception (OCR, document understanding) and reasoning (Chain-of-Thought, code generation) are separate stages connected by a serial pipeline. The paper provides empirical traction for this reframing through the VisAlg benchmark, where models that achieve high perceptual fidelity (faithfully transcribing symbols from images) and high general reasoning capability (scoring well on standard benchmarks) nonetheless fail to produce structurally correct DSL programs—they can read the problem and compute an answer, but they cannot reconstruct the logical topology that justifies the answer.

This reframing shifts the success criterion for visual reasoning systems. Prior work implicitly evaluates reasoning quality through answer accuracy: did the model get the right number? The paper argues this is insufficient because a model can get the right answer through flawed structural parsing—by computing correctly on a misinterpreted problem structure, or by leaking the answer into diagram labels without encoding the reasoning chain. The paper's composite evaluation framework (chrF + SSIM + LLM-judge) makes structural fidelity a first-class evaluation target alongside (or even instead of) answer accuracy. If adopted by other researchers, this would change how reasoning benchmarks are designed and how models are compared—moving from "is the answer right?" toward "is the reasoning structure provably consistent?" This is analogous to how software engineering moved from "does the program produce the right output on test cases?" toward "does the program satisfy formal specifications?"—a higher standard that catches errors invisible to black-box testing.

The paper reconciles a latent tension in the "Thinking with Images" literature. Recent work (Su et al., 2025; Chern et al., 2025; Zheng et al., 2025) has advocated for generating visual artifacts during reasoning, motivated by the observation that humans use drawing and visualization as cognitive tools. The paper's critique—that pixel-space generation is inherently imprecise and cannot enforce logical constraints—provides a framework for understanding when this approach succeeds (tasks where perceptual plausibility is sufficient) and when it fails (tasks requiring mathematical exactness). The paper does not argue that Thinking with Images is wrong; it argues that it operates in the wrong semantic space for rigorous reasoning. The DSL approach preserves the idea of visual feedback during reasoning but replaces stochastic pixel generation with deterministic programmatic rendering, making the visual output a proof rather than an illustration. This preserves the cognitive value of visual thinking while adding verifiability.

The paper redirects research attention toward verifier quality over search sophistication. The structural degeneration taxonomy (Semantic Erasure, Label Injection, Alignment Conflict) documents failure modes that are invisible to standard metrics but prevalent in state-of-the-art models. The paper shows that even Gemini-3-Pro—one of the strongest proprietary multimodal models—sometimes produces topologically broken diagrams (evidenced by its verification sub-scores in Table 2, where structural alignment is 0.97 but semantic compliance is only 0.78). This suggests that the bottleneck in visual reasoning is not computational capacity (these models have enormous scale) but enforcement of structural invariants—the models can compute but cannot constrain. This redirects research from "how can we make models reason better?" toward "how can we force models to produce structurally verifiable reasoning traces?" The answer the paper proposes—explicit supervision on a structured intermediate representation—is domain-specific but the direction is general: build reasoning systems where correctness is mechanically checkable, not just statistically correlated with scale.

The paper also makes a narrower but practically significant empirical claim that challenges scaling orthodoxy. The finding that an 8B model with structured supervision (82.63) exceeds Gemini-3-Pro (79.96) on this specific task—even with the zero-shot vs. fine-tuned confound—provides evidence that certain reasoning capabilities cannot be acquired through scale and general-purpose training alone. The paper does not argue that scale is irrelevant (the data is generated by a large model, and the 8B model's base capabilities come from pretraining), but rather that the format in which reasoning is expressed matters independently of the computational resources available to the reasoner. This is a specific claim with specific scope (bar-model visual algebra, in-distribution evaluation), but it adds to an emerging body of evidence that structured intermediate representations—whether code, formal logic, or domain-specific languages—can unlock capabilities that raw scale does not.

Follow-Up Research This Work Enables

Dissecting the fine-tuning vs. representation confound with controlled comparisons. The paper's headline result compares fine-tuned TwD against zero-shot proprietary models. The most important follow-up is to determine what fraction of TwD's advantage comes from the DSL representation itself versus from in-distribution training. A clean experiment: take the same 10,430 VisAlg training instances, reformat them as Chain-of-Thought supervision (textual reasoning traces leading to answers, no DSL), Program-of-Thought supervision (Python code computing answers), and standard DSL supervision (the current TwD format). Fine-tune identical Qwen3-VL-8B models on each format, then evaluate on the VisAlg test set across two axes: answer accuracy (which the current paper omits) and structural fidelity (using the existing metrics). If the DSL-trained model achieves higher answer accuracy than the CoT-trained model, the representation itself improves reasoning. If answer accuracy is similar but structural fidelity differs, the DSL provides verifiability without accuracy gains—still valuable, but a different claim. This experiment would cost modestly (three fine-tune runs on 10k examples) and would substantially sharpen the paper's contribution.

Quantifying the difficulty cliff: where does structured supervision stop working? The paper reports aggregate metrics across all 942 test instances but never breaks performance down by difficulty level, even though VisAlg includes difficulty labels (Easy/Medium/Hard, Table 1). A natural follow-up measures TwD's performance stratified by difficulty and by the number of reasoning operations required (the "operation length" statistic in Table 1). The hypothesis to test: TwD's advantage concentrates on easy-to-medium problems (where the DSL structure is learnable from training examples) and degrades on hard problems or those with ≥8 operations—the long dependency chains that produce the 24% rejection rate during data construction. If TwD's performance on hard problems is near the proprietary model baselines, the structural supervision helps on routine cases but doesn't solve the underlying difficulty sensitivity. If TwD maintains its advantage uniformly, the DSL representation genuinely generalizes to novel structural complexity within the bar-model domain. This experiment requires no new data collection—VisAlg already includes difficulty labels and operation counts.

Extending the structural degeneration taxonomy to other visual reasoning domains. The paper's error taxonomy (Semantic Erasure, Label Injection, Alignment Conflict) is developed for bar-model problems. A productive follow-up would map this taxonomy onto a different domain where structural invariants matter—geometry proof problems are the most natural candidate, since benchmarks like GeoQA and Geometry3K include both visual diagrams and formal logical structure. The experiment: prompt proprietary models (Gemini, GPT, Claude) to generate geometric proofs with accompanying diagrams, then manually annotate the outputs using an extended version of the taxonomy. Key questions: Do the same three categories appear in geometry, or do new failure modes emerge? Does the prevalence of topological errors correlate with problem difficulty in geometry as it appears to in bar-model reasoning? This would establish whether the precision paradox is a general property of multimodal reasoning or specific to the bar-model domain. The paper's set-theoretic example (Figure 7) suggests the taxonomy generalizes to at least some non-bar-model topologies, but systematic evidence is missing.

Developing a difficulty estimator for visual reasoning problems without ground-truth labels. The most immediately actionable limitation of the TwD approach is that it provides no mechanism for the system to recognize when it is producing a structurally broken output. Unlike the compute-optimal scaling literature (where difficulty estimation via PRM scoring enables adaptive strategy selection), TwD has no difficulty signal and no recovery strategy. A natural extension: during training, compute per-instance metrics of DSL quality (syntactic validity, alignment consistency, bracket boundary matching) and use these to train a lightweight classifier that predicts whether a novel problem will be within the model's capability range. At inference time, if the classifier predicts high difficulty, the system could fall back to a different strategy (e.g., request human assistance, generate multiple candidate DSLs and use a verifier to select the best, or switch to a simpler reasoning mode). The paper's existing verification metrics (Section 4.3) provide a starting point for the automated quality assessment; the challenge is making this assessment efficient enough to run at inference time (the current pipeline uses an LLM judge, which is too expensive for per-query deployment).

Testing whether the two-stage verification loop adds value through controlled ablation. The paper claims the rendering-feedback loop (Stage 1 → render → Stage 2 → refined output) is central to TwD but never ablates it. A straightforward experiment: evaluate TwD in a one-stage configuration (generate final DSL and answer without intermediate rendering) on the VisAlg test set, and compare structural fidelity and answer accuracy against the two-stage configuration at equal total output tokens. If the two-stage process produces measurably better outputs (more correct DSLs, higher verification scores), the rendering-feedback loop is functional. If it produces identical outputs, the loop is decorative—the model learns to correct its own errors during fine-tuning on refinement traces, but the visual rendering itself provides no additional signal beyond what the DSL code already contains. This experiment is cheap (inference-only, no retraining) and would directly inform deployment decisions: if the rendering loop doesn't help, a production system can omit it and halve latency.

Investigating whether answer leakage in proprietary models is a format familiarity artifact or a reasoning defect. The paper reports strikingly low answer leakage scores for proprietary models: Gemini-2.5-Pro scores 0.32 (68% of outputs leak the answer in labels), GPT-5.1 scores 0.19, while TwD scores 1.00 (zero leakage). A follow-up study would determine whether this reflects the models' inability to encode reasoning structure without leaking (a reasoning defect) or their unfamiliarity with the DSL convention that unknowns should be marked as "?" rather than computed inline (a format unfamiliarity artifact). The experiment: provide proprietary models with few-shot examples that demonstrate the no-leakage convention, then re-evaluate leakage scores. If leakage drops substantially (e.g., from 0.32 to 0.80+), the original results reflect format unfamiliarity—the models can produce non-leaking DSLs when shown the convention. If leakage remains high, the models genuinely struggle to separate structural representation from answer computation. This distinction matters for whether the leakage metric measures reasoning quality or prompt engineering effectiveness.

Practical Applications and Downstream Use Cases

Automated grading and feedback for bar-model math education. The bar-model method (Singapore math) is widely used in primary and secondary mathematics education across Asia and increasingly globally. Students solve word problems by drawing bar diagrams that encode quantitative relationships—the same diagrams TwD generates. A deployed TwD system could accept student-submitted word problem solutions (either the final answer or a photograph of a hand-drawn bar model), generate the correct DSL and rendered diagram, and compare the student's work against the verified structure. The system could provide specific feedback: "Your bar for Quantity A is correctly aligned with the reference bar, but the multiplicative unit segment is missing—you represented this as an additive relationship." The paper's high structural fidelity scores (0.90 structural alignment, 0.96 information coverage) suggest the generated diagrams are reliable enough for this use case on easy-to-medium problems. The current manual alternative—human teachers grading bar-model diagrams—is time-consuming, inconsistent, and does not scale to large classrooms or self-paced online learning. The 8B model size makes deployment on school hardware or cloud-based EdTech platforms feasible without the cost of proprietary API access.

Data generation for self-improving reasoning systems. The TwD paradigm—generate a structural hypothesis, render it, inspect the rendering, correct errors—provides a recipe for automatically generating high-quality reasoning traces that include verifiable intermediate states. A self-improvement loop following the STaR/ReST $^{EM}$ pattern (Zelikman et al., 2022; Singh et al., 2024) could work as follows: use a base model to generate DSL programs for novel bar-model problems, render and evaluate each DSL using automated verification checks (syntactic validity, alignment consistency, bracket boundary matching), retain only structurally valid outputs as additional training data, and fine-tune the model iteratively. The paper demonstrates that quality filtering (rejecting 24% of Gemini-2.5-Pro's drafts) produces training data that enables an 8B model to exceed its teacher—the same principle could be applied iteratively to improve the base model itself. The key enablers are the deterministic renderer (which makes verification automatic) and the canonical diagram form (which makes structural checks simpler than for free-form generation). This is likely more efficient than self-improvement on purely textual reasoning, where verification requires either human judgment or expensive LLM-as-judge calls.

Document understanding pipelines that go beyond transcription to semantic parsing. Modern OCR and document understanding systems (DeepSeek-OCR, PaddleOCR-VL, MinerU) can extract text, tables, and formulas from documents with high fidelity, but as the paper argues, they operate at the level of syntax—capturing what is written, not what it means. A document processing pipeline for scientific, mathematical, or financial documents could integrate a TwD-like component that takes the extracted symbols and question as input, generates a structured DSL representing the logical relationships, and uses the rendered diagram (or a programmatic equivalent) as a verifiable intermediate output. For instance, parsing a financial statement could involve extracting numbers from tables, constructing a DSL that encodes the accounting relationships (assets = liabilities + equity, revenue - expenses = profit), and rendering the DSL to verify that the relationships are satisfied. The value-add is not better transcription (existing OCR already extracts the numbers) but verifiable structural consistency—catching errors where extracted numbers satisfy individual field formats but violate cross-field constraints. The paper's 96% LLM-judge to human-expert agreement rate on DSL quality assessment suggests this verification could be largely automated.

When to Prefer This Method

The paper does not explicitly position TwD against named alternative reasoning paradigms (Chain-of-Thought, Program-of-Thought, Thinking with Images) in a comparative decision framework. The paper argues that TwD is necessary for visual algebra tasks requiring verifiable logical topology, and the experimental comparison against zero-shot proprietary models demonstrates that general-purpose approaches do not match TwD's structural fidelity without task-specific training. However, the paper does not provide evidence that allows a practitioner to decide whether TwD's structural verification adds value over alternative structured approaches (e.g., Python code execution, formal logic provers, or geometry-specific DSLs like in Inter-GPS) for other task types. The missing comparisons—fine-tuned CoT vs. fine-tuned DSL, one-stage vs. two-stage TwD, and answer accuracy reporting—mean the tradeoff space is underspecified. Including a preference matrix would require speculating about results the paper does not provide, so I do not include one here.