Engineering/Electronic Diagrams & CAD Survey

🎯 Core Advantages of TikZ Over SVG

1. High-level semantic commands vs. low-level paths: TikZ uses human-oriented commands like \draw (A) -- (B) expressing intent and relationships, while SVG uses primitive coordinates like <path d="M 50,100 L 150,100"/> with no semantic meaning
2. Explicitly encodes relationships: Spatial relationships (right of=input1), hierarchical structures (node grouping), and connectivity patterns (all-to-all connections via loops) are captured in the code itself
3. Captures symbolic meaning through abstraction: Concepts like "layers," "groups," and "patterns" are expressed through constructs like \foreach loops that reflect underlying architecture (e.g., neural network layers)
4. Maintains geometric precision with semantic intent: Commands like \node at (0,0) {Center} encode both position AND the semantic relationship (label belongs to circle's center), not just coordinates
5. Expresses complex structures concisely: Human TikZ code averages 916 tokens vs. GPT-4's simpler 187 tokens, but TikZ captures far more semantic complexity with commands that align with natural language descriptions

💡 Example: Multi-Layer Perceptron

TikZ captures semantic structure:

% Define neuron layers with semantic meaning
\foreach \i in {1,...,4}
    \node[neuron] (I-\i) at (0,-\i) {Input \#\i};
\foreach \i in {1,...,5}
    \node[neuron] (H-\i) at (2,-\i-0.5) {};
% All-to-all connectivity pattern
\foreach \i in {1,...,4}
    \foreach \j in {1,...,5}
        \draw[->] (I-\i) -- (H-\j);

What this encodes: Layers as conceptual groups, all-to-all connectivity pattern between layers, iteration structure reflecting neural network architecture

SVG equivalent: Would require manually specifying every single line coordinate with no concept of "layers" or "connections" - just raw geometric primitives

🧠 Why This Matters for Language Models

• Natural language alignment: TikZ commands like \draw, \node, \foreach align with how we describe figures in captions
• Compositional understanding: Models can learn that "multi-layer perceptron" → layers of nodes → all-to-all connections
• Fewer tokens, more meaning: Paper shows SVG methods "fail to maintain accurate geometric relations" (p.3) while TikZ creates "complex figures with only a few commands" that preserve semantic relationships

🧠 Required Reasoning Abilities

1. "Visual Imagination": LLMs must mentally simulate how symbolic operations render visually without seeing pixels
2. Long-range Sequential Reasoning: Operation order drastically affects semantics; requires tracking procedural generation steps
3. Fine-grained Grounding: Locating semantic components in program structure demands precise understanding of code-to-visual mapping
4. Multi-step Compositional Reasoning: E.g., "What is object primarily used for?" requires: identify object semantically → determine function → answer (errors in any step fail)
5. Numeric + Spatial + Geometric Understanding: Requires perceiving coordinates, dimensions, transformations, and their visual implications

💡 Example: CAD Reasoning (OpenAI-o1)

Task: "How many protruding cylindrical shafts are visible in the CAD object?"

O1's Step-by-Step Process:

• Step 1: Main shaft created via circle extrusion (radius 0.32, extrude 3.175 units)
• Step 2: Base ring added (annulus extruded downward, doesn't add shaft)
• Step 3: Cutting features (removes material, no new shafts)
• Step 4: Small ring added (doesn't count as shaft)
• Steps 5-6: Upper shaft created and extended
• Answer: 2 shafts (main shaft + upper shaft)

Demonstrates: Numeric perception, spatial reasoning, geometric understanding, long-range planning, and common sense

✅ SGP-Bench Performance Gains

Llama-3.1-8B improvement: 46.5% → 51.4% (+4.9%) with 55K SIT pairs

Scaling with data size:

• 10K pairs: 48.0% (+1.5%)
• 25K pairs: 50.3% (+3.8%)
• 40K pairs: 51.2% (+4.7%)
• 55K pairs: 51.4% (+4.9%)

🚀 General Reasoning Improvements (Llama-3.1-8B)

Notable gains with OI-mixed-SIT (Open-Instruct + original + reverse SIT):

• Instruction Following: IFEval-inst +5.6%, IFEval-prompt +3.5%
• Math Reasoning: GSM8k +3.3%, ASDiv +2.8%, Arithmetic +2.0%, MathQA +1.4%
• General Reasoning: AGIEval +7.9%, BigBenchHard +1.7%, PIQA +0.5%
• Language Understanding: C-Eval +1.7%, XNLI +1.1%, MMLU +1.2%
• Reading Comprehension: SQuAD2.0 +2.7%, CoQA +1.2%

Key Insight: Reverse SIT (description→program generation) provides complementary reasoning abilities to original SIT; mixed approach achieves best overall performance

🎯 Advantages of mxGraph Over Raster/SVG/TikZ

1. Preserves Symbolic Structure: Nodes, edges, hierarchy, semantic grouping, and layout constraints are explicitly encoded
2. Editable & Reusable: Compatible with draw.io, enabling direct editing, modification, and reuse in presentations/papers
3. Semantically Meaningful: Unlike SVG paths, mxGraph represents diagrams as structured graphs with typed elements (Process, Decision, Entity)
4. Layout Constraints: Explicit encoding of alignment, connection routing, and z-layering rules
5. Renderability Guarantee: XML can be validated and rendered programmatically via draw.io engine

💡 Problems with Existing Approaches

• SVG: Low-level shapes with poor semantic meaning, cannot express rich relational structures
• TikZ: Powerful but hard to parse, non-standardized, limited tool support
• Python Plot Code: Domain-specific, cannot express general diagram structures (flowcharts, architecture diagrams)
• Raw MLLMs: Struggle with structural accuracy, layout consistency, long XML generation, executable formatting

📋 Stage I: Coarse-to-Fine Planning

Step 1 - Perceptual Structuring:

• Extract: Gestalt grouping, hierarchical primitives, visual encodings (color/shape→meaning), connector topology
• Output: T_percept = (Gestalt, Hierarchy, Encoding, Connectors)

Step 2 - Semantic Specification:

• Generate: R (Regions: Input/Output/Modules), E (Typed elements: Process/Entity/Block/Arrow), L (Layout constraints: align, connect, layer)
• Output: T_hierarchy = (R, E, L) — the semantic blueprint

🔧 Stage II: Structure-Aware Code Generation

Step 3 - Initial XML Generation:

• Generate: Y_doc (XML root), Y_style (style dictionary), Y_node (symbolic nodes), Y_layout (positions + alignment), Y_edge (connectors + routing)

Step 4 - Multi-Round XML Refinement:

• Iteratively correct: Missing tags, mis-nested elements, schema violations
• Verify via draw.io validator: Syntactic correctness, rendering success, structural consistency
• Early stopping once valid XML is achieved

🎯 Paradigm Shift: Vectorization as Code Generation

Traditional Approach (Inverse Rendering): Edge detection → contour tracing → curve fitting → path primitives

StarVector Approach (Code Generation): Visual understanding → semantic interpretation → SVG code synthesis

Key Advantage: Language models learn "these pixel patterns correspond to circle primitives" rather than applying fixed heuristics

💡 Example: Circle Representation

Traditional Vectorization (AutoTrace/VTracer):

<!-- 50+ Bézier curve segments -->
<path d="M 100,50 C 100,22.4 77.6,0 50,0 C 22.4,0 0,22.4 0,50
         C 0,77.6 22.4,100 50,100 C 77.6,100 100,77.6 100,50 Z"/>
<!-- ...49 more path segments... -->
<!-- Result: ~500 tokens, uneditable -->

StarVector Output:

<circle cx="50" cy="50" r="50"/>
<!-- Result: ~1 token, editable, 50× more compact -->

Impact: Semantic understanding enables compact, human-readable, editable SVG code

✅ Image-to-SVG Quality (1,948 assessments, 30 participants)

Question: "Which SVG better represents the input image?"

StarVector-8B Win Rate:

• vs. LIVE: 68% wins
• vs. AutoTrace: 74% wins
• vs. VTracer: 71% wins

Diagram Generation Task:

• vs. LIVE: 89% wins (diagrams with readable text)
• vs. AutoTrace: 92% wins

Critical Finding: Only StarVector generates valid diagrams with text and structured elements - baseline methods produce unreadable path approximations

Why LaTeX/CircuitTikz for Training Data?

MAPS uses CircuitTikz (LaTeX package) to generate 20,000 synthetic training pairs for the PPM. This choice is critical:

SINGLE CircuitTikz CODE:
\begin{circuitikz}
  \draw (0,0) to[V, v=$10V$] (0,3)
        to[R=$5k\Omega$] (3,3)
        to[R=$10k\Omega$] (3,0)
        to (0,0);
\end{circuitikz}

           ↙                    ↘
OUTPUT 1:              OUTPUT 2:
[PNG Image]              SPICE Netlist
Circuit diagram          V1 n1 0 DC 10
with visual layout       R1 n1 n2 5k
                         R2 n2 0 10k
                         .op .end

         ↘                    ↙
        TRAINING PAIR
    (Image, SPICE) - Perfect Alignment!

🔧 Synthetic Data Generation Pipeline

1. Sample Circuit Parameters from hierarchical distribution:
   • Component counts (2-10 components)
   • Topology types (series, parallel, series-parallel, bridge, ladder)
   • Component values (resistances: 1k-10k, capacitances: 1pF-100μF)
   • Voltage sources (3V, 5V, 9V, 12V, etc.)
2. Generate CircuitTikz LaTeX Code programmatically
3. Compile to PDF/PNG using pdflatex + ImageMagick
4. Parse CircuitTikz → SPICE Netlist (structured syntax makes this straightforward)
5. Verify with NgSPICE - ensure valid circuit (reject invalid samples)
6. Add to Dataset: ppm-syn-lprc (20K pairs)

Result: 20,000 perfectly aligned (diagram image, SPICE netlist) pairs with zero human annotation!

✅ Why LaTeX > Other Approaches

📚 Hierarchical Complexity Control

LaTeX code enables curriculum learning by controlling circuit complexity:

• Simple (2-3 components): Series/parallel resistor networks
• Medium (4-6 components): Series-parallel combinations, voltage dividers
• Hard (7-10 components): Bridge circuits, ladder networks, mesh analysis

Key Benefit: Training data distribution matches real college-level problem difficulty, minimizing domain gap!