🔢 mathematics

TreeWidzard: An Engine for Width-Based Dynamic Programming and Automated Theorem Proving

This paper introduces TreeWidzard, a unified engine that facilitates the development and combination of treewidth-based dynamic programming algorithms to decide complex graph properties and support automated theorem proving.

Original authors: Mateus de Oliveira Oliveria, Sam Urmian

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mateus de Oliveira Oliveria, Sam Urmian

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a massive jigsaw puzzle, but instead of a picture, the puzzle is a complex network of connections (like a social network, a road map, or a computer chip). Some of these puzzles are so complicated that checking every single piece to see if they fit together would take longer than the age of the universe.

However, there's a special trick: if the puzzle can be broken down into small, manageable chunks that overlap in a specific, tree-like pattern, you can solve it much faster. This "tree-like pattern" is called treewidth.

TreeWidzard is a new software engine created by Mateus de Oliveira Oliveira and Sam Urmian. Think of it as a super-smart, modular puzzle solver that specializes in these tree-like networks. It doesn't just solve one puzzle; it helps you build the rules for solving any puzzle of this type, and then it can even prove whether a rule works for every possible puzzle of a certain size.

Here is how it works, broken down into simple concepts:

1. The Building Blocks: "Instruction Trees"

Usually, to solve a graph problem, you need the whole graph and a map of how to break it down. TreeWidzard uses a clever shortcut called an Instruction Tree Decomposition (ITD).

Imagine you are giving a robot instructions to build a house. Instead of showing the robot a picture of the finished house, you give it a step-by-step recipe:

"Add a brick here."
"Add a window there."
"Connect these two walls."
"Forget about that temporary scaffold (it's no longer needed)."

TreeWidzard treats graphs like these recipes. It doesn't look at the whole messy house at once; it follows the recipe from the bottom up, building the solution piece by piece.

2. The "DP-Cores": The Specialized Workers

The heart of TreeWidzard is something called a DP-core (Dynamic Programming core). Think of these as specialized workers on an assembly line.

The Worker's Job: Each worker is an expert in one specific task, like "Counting the colors needed to paint this house so no two neighbors have the same color" or "Finding the largest group of people who don't know each other."
Modularity: The best part is that these workers are composable. You can take the "Coloring Worker" and the "Group-Finding Worker" and snap them together like Lego bricks. If you need a worker who finds the largest group of people who also have a specific color pattern, you just combine the two existing workers. You don't have to build a new worker from scratch.

3. Two Main Superpowers

TreeWidzard uses these workers for two distinct purposes:

A. Checking a Specific Puzzle (Model Checking)
You hand TreeWidzard a specific graph (a specific puzzle) and ask, "Does this graph satisfy property X?"

Example: "Is this specific road map 3-colorable?"
The engine runs the workers up the instruction tree. If the final result is "Yes," it tells you the graph is valid. If "No," it tells you it's not.

B. Proving Rules for All Puzzles (Automated Theorem Proving)
This is where TreeWidzard gets really powerful. Instead of checking one graph, it asks: "Does this rule work for every single possible graph that fits this tree-like pattern?"

Example: "Are all graphs with a tree-width of 4 capable of being colored with 5 colors?"
TreeWidzard simulates every possible way to build such a graph.
- If the answer is YES: It confirms the rule is true for the entire class of graphs.
- If the answer is NO: It doesn't just say "No." It acts like a detective and produces a specific counterexample. It builds a concrete graph that breaks the rule, so you can see exactly why the rule failed.

4. The Magic Tricks: Symmetry and Pruning

Checking every possible graph sounds impossible because there are too many. TreeWidzard uses two "magic tricks" to make this feasible:

Symmetry Breaking (The "Mirror" Trick): Imagine you are checking a puzzle. If you rotate the puzzle 90 degrees, it's essentially the same puzzle. TreeWidzard realizes this. It ignores the rotated versions and only checks the "original" version. This saves a massive amount of time by not doing the same work twice.
Pruning (The "Early Exit" Trick): Imagine you are checking a rule that says, "If a graph has more than 20 vertices, it must be red." As soon as TreeWidzard starts building a graph and counts 21 vertices, it knows the rule is already broken for that branch. It stops building that specific graph immediately and moves on. This cuts out huge branches of the search tree that don't need to be explored.

Why This Matters

Before TreeWidzard, proving these kinds of graph rules often relied on complex mathematical logic that was slow and hard to tweak. TreeWidzard changes the game by letting researchers:

Write simple, modular code for specific graph properties.
Combine them to test complex theories.
Automatically verify if those theories hold true for entire families of graphs, or find the exact exception that breaks them.

In short, TreeWidzard is a construction kit for graph algorithms that turns the difficult task of proving mathematical theorems about networks into a manageable, automated process. It allows researchers to test big conjectures (like "Is every graph of this type 5-colorable?") and get a definitive answer, complete with a proof or a counterexample, much faster than before.

Technical Summary: TreeWidzard

Problem Statement
The paper addresses two interconnected challenges in graph theory and algorithm design:

Instance-Level Decision: Efficiently deciding graph-theoretic properties (e.g., chromatic number, independent set) on specific graphs, particularly those with bounded treewidth or pathwidth.
Width-Based Automated Theorem Proving (ATP): Determining whether all graphs of a given width $k$ satisfy a specific property. While Courcelle's theorem provides a theoretical framework for this using Monadic Second-Order (MSO) logic, the resulting algorithms suffer from non-elementary complexity (a tower of exponentials) relative to the formula's quantifier alternation depth, rendering them impractical even for small widths.

Methodology
The authors introduce TreeWidzard, a C++ engine that implements a framework for width-based automated theorem proving and dynamic programming (DP). The methodology diverges from the traditional automata-theoretic approach (compiling logical formulas into tree automata) by instead compiling dynamic programming algorithms into the engine.

Key methodological components include:

Instruction-Term Decompositions (ITD): Instead of manipulating standard tree decompositions directly, TreeWidzard uses an algebraic instruction set ( $\Sigma_k$ ) comprising operations like Leaf, Join, IntroVertex, ForgetVertex, and IntroEdge. These instructions form terms that encode both the graph construction and its decomposition shape.
DP-Cores: The core abstraction is the "DP-core," a modular component representing a specific graph property or invariant. A DP-core consists of:
- A witness representation (local state) storing partial information.
- Transition functions corresponding to each ITD instruction (handling leaf, join, vertex introduction, edge introduction, and vertex forgetting).
- Auxiliary functions for witness comparison, relabeling (for symmetry breaking), hashing, and invariant extraction.
- A final witness test and an optional cleaning function for redundancy removal.
Compositionality: DP-cores are designed as independent, composable units. Complex properties are defined as Boolean combinations of simpler DP-cores.
Search Strategies: For ATP, the engine performs a breadth-first search over the space of all $k$ $k$ -instructive tree decompositions. It employs two key optimizations to manage state explosion:
- State Canonization: Breaking symmetries by identifying isomorphic local witnesses (relabeling invariance).
- Premise Pruning: For implications $A \implies B$ where $A$ is closed under subgraphs, the search prunes branches where the premise is violated, as the implication holds trivially downstream.

Key Contributions

System Description: The paper provides a comprehensive system description of TreeWidzard, detailing its architecture, file formats (supporting both PACE/DIMACS and native ITD formats), and usage for model checking, invariant computation, and ATP.
Implementation Framework: It offers a step-by-step guide for implementing DP-cores in C++, illustrated through two concrete examples:
- ChromaticNumber_AtMost: A decision core determining if a graph is $c$ -colorable.
- IndependenceNumber: An optimization core computing the size of the maximum independent set.
Unified Workflow: The engine unifies instance-level model checking and bounded-width validity checking. The same DP-cores used to verify a single graph can be used to prove that all graphs of width $k$ satisfy a property.
Counterexample Generation: If a property is not valid for all graphs of width $k$ , TreeWidzard is guaranteed to produce a concrete counterexample graph (provided the DP-cores satisfy finiteness and coherence conditions).

Results and Demonstrations
The paper demonstrates the engine's capabilities through several use cases:

Model Checking: Verifying that a specific "diamond graph" is 3-colorable and computing its independence number (2).
Automated Theorem Proving:
- Confirming that all graphs of treewidth $\le 4$ are 5-colorable.
- Refuting the claim that all graphs of treewidth $\le 4$ are 4-colorable, successfully generating a counterexample (the complete graph $K_5$ ).
Optimization Impact: The authors show that using symmetry breaking (ParallelIsomorphismBreadthFirstSearch) drastically reduces the search space. For the 5-colorability check on width 4, the state count dropped from 1,450 (standard BFS) to 53 (canonical BFS).
Premise Pruning: The paper illustrates how premise pruning can convert an unbounded search space into a finite one for specific implication structures.

Significance and Claims
The paper positions TreeWidzard as a practical tool for bridging the gap between theoretical parameterized complexity and automated reasoning.

Complexity Advantage: Unlike Courcelle-based approaches where complexity grows as a tower of exponentials with formula depth, TreeWidzard's complexity is double exponential in the size of the local information (witnesses) used by the DP-cores. This makes it feasible to test prominent conjectures (e.g., Hadwiger's, Tutte's, Reed's) on bounded-width graph classes.
Modularity: The framework allows researchers to package familiar width-based algorithms as reusable, composable modules, facilitating the rapid development of new decision procedures and invariant computations.
Practicality: By integrating symmetry breaking and pruning, the engine addresses the "state explosion" problem inherent in exhaustive width-based searches, enabling the practical evaluation of graph properties on classes of bounded treewidth and pathwidth.

The authors conclude that TreeWidzard serves as a "laboratory" for developing width-based dynamic programming algorithms and investigating graph-theoretic conjectures on bounded-width graph classes, offering a formalism that reconciles automata-based compilation with dynamic programming.