Exact Pattern-Aware Extraction for Equality Saturation via Bounded-Depth Tree Covering

1. Introduction

Equality saturation explores the space of equivalent program expressions by encoding them in an e-graph (Willsey, Nandi,Wang, Flatt, Tatlock & Panchekha, 2021; Tate, Stepp, Tatlock & Lerner, 2009; Nelson & Oppen, 1980). Its final step—extraction—selects one representative per equivalence class to form a concrete output tree, directly determining the quality of the optimization pipeline.

Downstream consumers of e-graph output—including SMT solver preprocessors (De Moura & Bjørner, 2008) and compiler instruction selectors (Blindell, 2016; Aho, Ganapathi & Tjiang, 1989)—perform their most valuable simplifications through predefined pattern-matching passes that recognize specific multi-node operator configurations. However, these systems apply rewrites through a fixed sequence of local passes, each transforming expressions one at a time, limiting their ability to reshape an expression into the triggering form for their own heuristics. Equality saturation can bridge this gap by exploring equivalent expressions simultaneously and locating pattern-satisfying variants that no fixed sequence of local rewrites would produce. Extraction must therefore select among equivalents by downstream pattern value rather than by a generic proxy such as expression size.

Standard extraction discards this opportunity. The widely used egg framework (Willsey, Nandi, Wang, Flatt, Tatlock & Panchekha, 2021) employs a decomposable, single-node cost function—typically AST size—that evaluates each candidate independently of its parent context and commits to a global selection reused wherever the class is referenced. This mechanism is structurally unable to encode the joint value of multi-node pattern matches: two candidates of equal AST size that differ only in pattern-matching value receive identical scores (Section 3).

We formalize pattern-aware extraction as a weighted pattern cover problem on AND-OR DAGs, establishing its correspondence to tree covering in compiler instruction selection (Blindell, 2016; Pelegri-Llopart & Graham, 1988; Aho, Ganapathi & Tjiang, 1989). Three challenges arise when migrating tree covering to e-graphs: annotation ambiguity from multiple candidates per equivalence class, context-dependent selection caused by depth-2 pattern templates, and DAG sharing conflict among parent references. Fully general extraction with arbitrary non-decomposable cost functions is NP-hard (Tate, Stepp, Tatlock & Lerner, 2009); however, practical pattern templates have bounded depth—typically at most two—and this structural restriction admits a specialized, exact, polynomial-time algorithm.

To exploit this observation, we propose an extraction algorithm based on tree DP with three mutually exclusive tile-role states—independent, tile-root, and tile-leaf—that jointly capture the coupling between candidate selection and tile assignment. The algorithm rests on the insight that the extraction output is a tree: each reference to a shared equivalence class corresponds to an independent tree position resolvable with its own parent context. A bottom-up pass computes structural compatibility signatures and optimal DP values for each state; a top-down pass traces back the optimal decisions to produce the output tree. We prove that for template sets with depth at most two, this yields an exact optimum in $O(N·K·|\mathcal{P}|·C_{max})$ time. The main contributions are:

1.

We formalize pattern-aware extraction from e-graphs as a weighted pattern cover problem on AND-OR DAGs and establish its structural correspondence to tree covering in compiler instruction selection.

2.

We identify three challenges—OR-node annotation ambiguity, context-dependent selection, and DAG sharing conflict—that arise when extending tree covering to e-graphs, and demonstrate how DAG-to-tree unfolding resolves them.

3.

We show that the coupled selection-tiling problem reduces to a tree DP with three mutually exclusive tile-role states, and design an exact algorithm generalizing BURS tree covering from fixed trees to AND-OR DAGs in $O(N·K·|\mathcal{P}|·C_{max})$ time.

4.

We present experiments comparing the proposed algorithm against standard egg extraction on weighted pattern coverage, exactness, and runtime.

2. Preliminaries and Problem Formulation

2.1. E-Graphs and Extraction

An e-graph $\mathcal{G}=(\mathcal{C},\mathcal{N})$ consists of a finite set of equivalence classes (e-classes) $\mathcal{C}$ and a finite set of e-nodes$\mathcal{N}$ (Willsey, Nandi,Wang, Flatt, Tatlock & Panchekha, 2021; Nelson & Oppen, 1980). Each e-node $n\in \mathcal{N}$ has the form $\mathrm{Op}(c_1,\dots ,c_k)$, where $\mathrm{Op}$ is an operator symbol with arity $k\ge 0$ and $c_1,\dots ,c_k\in \mathcal{C}$ are its child e-classes. Every e-node belongs to exactly one e-class, and all e-nodes within the same e-class represent expressions that have been proven equivalent by the rewrite rules applied during saturation. Each e-class additionally carries analysis data—a summary of semantic properties (such as constant values, bit-widths, or variable occurrences) computed by a lattice-based fixed-point procedure over the e-graph (Willsey, Nandi, Wang, Flatt, Tatlock & Panchekha, 2021).

An e-graph admits a natural interpretation as an AND-OR directed acyclic graph. Each e-class acts as an OR node—exactly one of its member e-nodes must be selected—while each e-node acts as an AND node—once selected, all of its child e-classes must be recursively resolved. Extraction is the process of traversing this AND-OR DAG to produce a concrete expression tree. In standard extraction (Willsey, Nandi, Wang, Flatt, Tatlock & Panchekha, 2021), a selection function $\varphi :\mathcal{C}\to \mathcal{N}$ maps each e-class c to a single representative $\varphi \left(c\right)\in c$. The resulting output $T\left(\varphi \right)$ is a tree obtained by recursively expanding from a designated root e-class. Because $\varphi$ assigns a single e-node to each e-class globally, every reference to the same e-class in the DAG resolves to the same candidate.

2.2. Pattern Templates

To formalize the notion of valuable multi-node structure that a downstream system can exploit, we introduce pattern templates.

Definition 1.

Apattern template is a four-tuple $p=(S_p,{\Pi }_p,d_p,w_p)$ where:

• $S_p$ is astructural schema—a rooted operator tree of depth $d_p$ in which each position is annotated with either a required operator type or a wildcard ∗;
• ${\Pi }_p$ is a set of predicate constraints over the analysis data of the e-classes at the schema positions (e.g., “the second child is a constant shift amount,” or “the sibling operand is a contiguous low-bit mask”);
• $d_p\in \{1,2\}$ is the template depth;
• $w_p\in {\mathbb{R}}^{+}$ is a positive weight reflecting the simplification value of the pattern.

Template depth is the key parameter that governs algorithmic difficulty. A depth-1 template constrains only a single e-node and its immediate children; its match status can be determined from the e-node and its children’s analysis data alone. Structural primitives such as bit-field extraction ($\mathtt{Extract}$) or zero-extension ($\mathtt{ZeroExtend}$) are recognized as depth-1 templates, since the downstream system processes them directly without further transformation. A depth-2 template additionally constrains the parent operator. The canonical example is $\mathtt{Eq}\left(\mathtt{BvAdd}(x,c),\mathit{k}\right)$ with joint predicates “$\mathtt{BvAdd}$’s first operand is a variable” and “k is a constant.” The downstream simplifier can then isolate the variable ($x=k-c$), triggering variable elimination. However, this applicability cannot be assessed without examining the parent–child pair together, since neither a standalone $\mathtt{BvAdd}$ nor a standalone $\mathtt{Eq}$ (whose arguments are not bare variables) satisfies any depth-1 template.

The weight $w_p$ reflects how much simplification value a matched pattern contributes. Patterns that directly eliminate variables or collapse multiple operations into a single primitive receive higher weights, while patterns that merely improve encoding efficiency receive lower weights. For depth-2 templates, a strict super-additivity constraint is imposed: the joint weight satisfies $w_p>w_1^{max}\left({\mathrm{Op}}_{\mathrm{parent}}\right)+w_1^{max}\left({\mathrm{Op}}_{\mathrm{child}}\right)$, where $w_1^{max}\left(\mathrm{Op}\right)$ denotes the best depth-1 weight achievable by operator type $\mathrm{Op}$. This constraint reflects a structural property of downstream simplification systems such as SMT solver preprocessors (De Moura & Bjørner, 2008): the heuristic trigger patterns recognized by depth-2 templates—variable isolation, bit-field decomposition, and similar compound simplifications—yield simplification value that is inherently greater than the sum of their individual components, because the joint recognition enables a qualitatively different transformation (e.g., variable elimination) that neither component alone can trigger. Super-additivity also ensures that the three-state DP strictly prefers state ↓ whenever a depth-2 template applies, enabling the ablation experiment (Section 6) to cleanly isolate the incremental contribution of depth-2 tiling. The full set of pattern templates $\mathcal{P}$ is derived systematically from the simplification rules of the target downstream system; we assume $\left|\mathcal{P}\right|$ is a moderate constant in practice.

2.3. Optimization Objective

Given an e-graph $\mathcal{G}$ and a pattern template set $\mathcal{P}$, the extraction objective is to select a tree $T\left(\varphi \right)$ that maximizes the total weighted pattern coverage. We formulate this objective as a tree covering problem, directly adopting the classical framework from compiler instruction selection (Blindell, 2016; Pelegri-Llopart & Graham, 1988; Aho, Ganapathi & Tjiang, 1989). Let $\mu (v,p)$ be a Boolean predicate that evaluates to $\mathit{true}$ if and only if tree node v—together with its parent in $T\left(\varphi \right)$ when $d_p=2$—satisfies the structural schema $S_p$ and all predicate constraints ${\Pi }_p$ of template p.

A covering of a tree T partitions its nodes into non-overlapping tiles, each matching a template from $\mathcal{P}$. A depth-1 tile covers a single node v with value equal to the weight of the best matching depth-1 template, or zero if no template matches. A depth-2 tile covers a parent–child pair $(u,v)$ with value $w_p$ from the matching depth-2 template; this weight represents the joint simplification value of the two-node combination and subsumes both individual depth-1 contributions that the tile replaces. The cover value of a tree is the total weight under its optimal covering:

$$CoverValue\left(T\right)=\underset{\mathcal{T}\in \mathrm{Cov}\left(T\right)}{max}\sum _{t\in \mathcal{T}}w\left(t\right),$$

(1)

where $\mathrm{Cov}\left(T\right)$ denotes the set of valid coverings of T and $w\left(t\right)$ is the weight of tile t. A structural constraint on the template set is mutual exclusivity: for any tree node v with determined parent context, at most one $p\in \mathcal{P}$ satisfies $\mu (v,p)=\mathit{true}$. This is natural since the downstream simplification rules apply disjointly; any residual overlap is resolved by retaining only the highest-weight template for each schema. Because a depth-2 tile covers a parent–child pair, each parent node can participate in at most one depth-2 tile. When depth-2 templates apply at multiple child positions of the same parent, the algorithm selects the single most beneficial option (Section 4).

Under mutual exclusivity, the tile assignment at each tree node reduces to selecting one of three mutually exclusive roles: using a depth-1 tile independently, serving as root of a depth-2 tile with one child, or being subsumed as leaf of a parent’s depth-2 tile. This three-way choice with local parent–child coupling admits a tree DP formulation (Section 4). The key difference from classical tree covering is that our problem must simultaneously select the tree from the AND-OR DAG and optimize its covering—the tree itself is a decision variable, introducing the challenges analyzed in Section 3.

3. Challenges: Beyond Classical Tree Covering

Classical tree covering (Pelegri-Llopart & Graham, 1988; Aho, Ganapathi & Tjiang, 1989) operates on a fixed expression tree where every node has a predetermined operator, enabling straightforward bottom-up annotation and top-down selection. The AND-OR DAG structure of an e-graph violates this premise in three ways.

3.1. OR-Node Annotation Ambiguity

In a fixed expression tree, each node carries a single operator, and the set of patterns applicable at that node is deterministic. In an e-graph, each e-class (OR node) contains multiple semantically equivalent e-nodes whose operator types may differ entirely. When a bottom-up pass reaches an e-class c, there is no single operator to annotate: one e-node in c may be $\mathtt{BvAdd}(c_1,c_2)$, another $\mathtt{BvOr}(c_1,c_2)$ (semantically equivalent when the operands have non-overlapping bit ranges). Each exposes a different operator to any parent referencing c—the former can participate in variable-isolation templates under an equality parent, while the latter cannot. Consequently, the pattern-match status of c is not a fixed attribute but a function of the selection decision$\varphi \left(c\right)$—a variable that has not yet been determined at annotation time. A bottom-up pass must therefore retain annotation information for every candidate in every e-class rather than committing to a single best choice, multiplying the state space relative to classical tree covering.

3.2. Context-Dependent Selection

The ambiguity described above could, in principle, be resolved by a single bottom-up pass that evaluates all candidates and selects the one maximizing the depth-1 contribution. Depth-2 pattern templates defeat this strategy by coupling the child’s value to the parent’s identity.

Consider an e-class c containing two candidates: $n_1=\mathtt{BvAdd}(c_x,c_{\mathit{off}})$ and $n_2=\mathtt{BvOr}(c_x,c_{\mathit{off}})$, both semantically equivalent because the operands occupy non-overlapping bit ranges. Evaluating depth-1 templates alone, $n_1$ receives $w_1\left(n_1\right)=0$ (addition does not match any depth-1 template), while $n_2$ matches a depth-1 bitwise-OR simplification template with $w_1\left(n_2\right)=w_1>0$—bitwise OR avoids the carry-chain propagation inherent in addition, making it the preferred operand form; a single bottom-up pass would therefore commit to $n_2$. Now suppose a parent e-node $n_{\mathrm{par}}=\mathtt{Eq}(c,c_k)$ exists, where $c_k$ holds a constant and neither argument of the equality is a bare variable ($w_1\left(n_{\mathrm{par}}\right)=0$ at depth-1). If c selects $n_1=\mathtt{BvAdd}$ instead of the depth-1-optimal $n_2$, the parent–child pair jointly satisfies the depth-2 variable-isolation template described in Section 2.2: the downstream simplifier recognizes $\mathtt{Eq}(\mathtt{BvAdd}(x,c_{\mathit{off}}),k)$ and derives $x=k-c_{\mathit{off}}$, triggering variable elimination with weight $w_p>w_1$. Under a different parent—say $\mathtt{BvUle}(c,c^{\prime })$—no depth-2 template applies, and the depth-1 preference for $n_2$ remains optimal.

The crux is that a bottom-up pass processes c before any parent information is available, yet the optimal selection depends on the parent operator—breaking the optimal substructure that single-pass dynamic programming requires. Neither a pure bottom-up pass (lacking parent context) nor a pure top-down pass (lacking subtree costs) can resolve this dependency alone.

This context dependence is a structural limitation of decomposable, single-node cost functions, which satisfy three invariants: (i) decomposability—cost decomposes additively over individual nodes; (ii) context independence—evaluation does not depend on the parent operator; and (iii) global commitment—each equivalence class receives a single selection reused at every reference site. Invariant (ii) prevents encoding the joint value of a parent–child pair, and invariant (iii) prevents executing different selections at different tree positions. As Figure 1 illustrates, the two candidates in c have identical AST size, and a depth-1 evaluation globally prefers $n_2$ ($w_1>0$); yet only $\mathtt{BvAdd}$ enables the depth-2 match under $\mathtt{Eq}$—neither a decomposable cost function nor a depth-1-only evaluation captures this position-specific opportunity.

3.3. DAG Sharing Conflict

Context-dependent selection is further complicated by DAG sharing—a characteristic that renders optimal covering on shared DAGs NP-complete (Blindell, 2016; Koes & Goldstein, 2008). A single e-class may be referenced by multiple parents imposing different depth-2 requirements. As in Figure 1, $\mathtt{Eq}(c,c_k)$ prefers c to select $\mathtt{BvAdd}$ for variable isolation, while $\mathtt{BvUle}(c,c^{\prime })$ prefers $\mathtt{BvOr}$. Under global selection, optimizing for one parent context necessarily sacrifices the other.

These three challenges are absent from classical tree covering (Pelegri-Llopart & Graham, 1988; Aho, Ganapathi & Tjiang, 1989) and collectively preclude direct migration of instruction-selection algorithms. In Section 4, we show that the tree-shaped nature of the extraction output resolves these difficulties: each reference to a shared e-class corresponds to an independent tree position resolvable with its own parent context.

4. Extraction Algorithm

4.1. Key Insight: Extraction Output Is a Tree

The extraction output is a concrete expression tree: when the same e-class is referenced at multiple positions, each reference corresponds to an independent tree node. Because all candidates within an e-class are semantically equivalent, different positions may select different candidates without affecting correctness. Unfolding the AND-OR DAG into the output tree ensures that every node has exactly one parent, making the tile-role assignment at each position unambiguous—mirroring the standard DAG-to-tree unfolding in compiler instruction selection (Blindell, 2016; Koes & Goldstein, 2008).

This insight enables a two-pass solution: a bottom-up pass computes optimal subtree values under every possible tile-role assignment, and a top-down pass traces back these pre-computed values to construct the output tree. Table 1 summarizes the design rationale.

4.2. Three-State Tree-Covering DP

Tile-role states. The coupling between candidate selection and tile assignment (Section 3) is resolved by decomposing each node’s role into three mutually exclusive states:

• State − (independent): the node forms a depth-1 tile with weight $w_1\left(n\right)$; all children are free (state − or ↓).
• State ↓ (tile-root): the node forms a depth-2 tile with one selected child; the chosen child enters state ↑, all others remain free.
• State ↑ (tile-leaf): the node is committed by its parent’s depth-2 tile and forms no tile of its own; all children are free.

A node cannot simultaneously be tile-root and tile-leaf, as this would place it in two overlapping tiles. The assignment of state ↑ is decided by the parent: the parent evaluates whether committing the child improves the total covering value. This asymmetry resolves depth-2 context dependence (Section 3.2) without violating optimal substructure. The three states with parent–child coupling ($\downarrow \leftrightarrow \uparrow$) form a tree DP with constrained state assignment—a well-studied problem class encompassing maximum weighted matching and maximum independent set on trees. Each state’s optimal value depends only on the subtree below the node; the parent’s influence is limited to which state the node enters.

Template compilation and structural information. Before the DP begins, the template set $\mathcal{P}$ is compiled offline into two hash-indexed lookup tables: ${\mathcal{T}}_1\left[\mathrm{Op}\right]$ maps each operator to its depth-1 templates, and ${\mathcal{T}}_2[{\mathrm{Op}}_p,\mathrm{pos},{\mathrm{Op}}_c]$ maps each (parent operator, child position, child operator) triple to its depth-2 templates. Both support $O\left(1\right)$ lookup; a single key may index multiple templates differing only in predicate constraints ${\Pi }_p$.

For each e-node $n=\mathrm{Op}(c_1,\dots ,c_k)$, the bottom-up pass first computes three structural quantities. The depth-1 match weight is:

$$w_1\left(n\right)=\left\{\begin{array}{ll}{\displaystyle \underset{\begin{array}{c}p\in {\mathcal{T}}_1\left[\mathrm{Op}\right]\\ {\Pi }_p\mathrm{satisfied}\end{array}}{max}}{w}_p\hfill & \mathrm{if}\mathrm{some}\mathrm{depth}\text{-}1\mathrm{template}\mathrm{matches},\\ 0\hfill & \mathrm{otherwise}.\end{array}\right.$$

(2)

The predicate profile $\pi \left(n\right)$ is a bitvector summarizing child properties: $\pi \left(n\right)\left[i\right]=1$ if child e-class $c_i$ contains only constants or variables. The compatibility signature$\sigma \left(n\right)$ is a bitvector over operator types, where $\sigma \left(n\right)\left[f_p\right]=1$ iff there exists a position i and a template $p\in {\mathcal{T}}_2[f_p,i,\mathrm{Op}]$ whose predicates ${\Pi }_p$ are satisfied. Informally, $\sigma \left(n\right)$ encodes which parent operators could form a depth-2 tile with n as tile-leaf. Because the input space $(\mathrm{Op},\pi )$ is finite, the mapping $(\mathrm{Op},\pi )\to \sigma$ can be pre-compiled into a static lookup table—analogous to BURS automaton state compilation (Pelegri-Llopart & Graham, 1988; Proebsting, 1995)—yielding $O\left(1\right)$ per e-node. The per-e-class aggregate ${\sigma }^{\cup }\left(c\right)={\bigvee }_{n\in c}\sigma \left(n\right)$ enables pruning: if ${\sigma }^{\cup }\left(c\right)\left[\mathrm{Op}\right]=0$, no candidate in c can serve as tile-leaf for parent operator $\mathrm{Op}$, and the depth-2 evaluation for that child position is skipped entirely.

Bottom-up DP values. The bottom-up pass requires an acyclic e-graph; cyclic e-nodes are removed by a standard preprocessing step (Willsey, Nandi,Wang, Flatt, Tatlock & Panchekha, 2021). For each e-node $n=\mathrm{Op}(c_1,\dots ,c_k)$ in topological order, after computing structural information, three DP values are computed. In state ↑ (tile-leaf), n is committed by its parent and forms no tile:

$$V^{\uparrow }\left(n\right)=\sum _{i=1}^k{V}^{*}\left(c_i\right).$$

(3)

In state − (independent), n uses its depth-1 tile:

$$V^{-}\left(n\right)=w_1\left(n\right)+V^{\uparrow }\left(n\right).$$

(4)

In state ↓ (tile-root), n selects child position j, template p, and candidate $n_j^{\prime }\in c_j$ to form a depth-2 tile; $n_j^{\prime }$ enters state ↑, other children are free:

$$V^{\downarrow }\left(n\right)=\underset{\begin{array}{c}j,n_j^{\prime }\in c_j,p\in {\mathcal{T}}_2\\ {\Pi }_p\mathrm{satisfied}\end{array}}{max}\left(w_p+V^{\uparrow }\left(n_j^{\prime }\right)+{\sum }_{i\ne j}{V}^{*}\left(c_i\right)\right).$$

(5)

If no depth-2 template matches, $V^{\downarrow }\left(n\right)=-\infty$. After all e-nodes are processed, each e-class aggregates the best free value:

$$V^{*}\left(c\right)=\underset{n\in c}{max}max\left(V^{-}\left(n\right),V^{\downarrow }\left(n\right)\right).$$

(6)

$V^{*}\left(c\right)$ does not bind a specific candidate; candidate selection is deferred to trace-back. The complete bottom-up procedure is given in Algorithm 1.   

Algorithm 1: Bottom-Up DP Pass

    Top-down trace-back. Starting from the root e-class, the trace-back recursively selects candidates and assigns tile roles using pre-computed DP values. When an e-class c is free (not committed by its parent), the procedure selects the candidate $n^{*}$ achieving $V^{*}\left(c\right)$ and compares $V^{\downarrow }\left(n^{*}\right)$ against $V^{-}\left(n^{*}\right)$. If $V^{\downarrow }\left(n^{*}\right)>V^{-}\left(n^{*}\right)$, $n^{*}$ enters state ↓: it forms a depth-2 tile with the recorded best child $n_j^{\prime }$, which enters state ↑, while all other children are recursed as free. Otherwise, $n^{*}$ enters state − and all children are free. When c is committed with a specific candidate $n_c$, that candidate enters state ↑: no tile is formed and all children are recursed as free.

Recursive calls carry no visit markers: each tree position makes an independent decision with its own parent context, resolving sharing conflicts through DAG-to-tree unfolding (Section 3.3). The complete procedure is given in Algorithm 2.   

Algorithm 2: Top-Down Pass: Trace-Back

4.3. Illustrative Example

We revisit the running example from Section 3 (Figure 2a). E-class c contains $n_1=\mathtt{BvAdd}(c_x,c_{\mathit{off}})$ and $n_2=\mathtt{BvOr}(c_x,c_{\mathit{off}})$. Candidate $n_1$ does not match any depth-1 template, so $w_1\left(n_1\right)=0$; candidate $n_2$ matches a depth-1 bitwise-OR simplification template with $w_1\left(n_2\right)=w_1>0$. Denoting $S=V^{*}\left(c_x\right)+V^{*}\left(c_{\mathit{off}}\right)$, the bottom-up pass yields $V^{\uparrow }\left(n_1\right)=V^{\uparrow }\left(n_2\right)=S$, $V^{-}\left(n_1\right)=S$, and $V^{-}\left(n_2\right)=w_1+S$. Neither serves as tile-root, so $V^{\downarrow }\left(n_1\right)=V^{\downarrow }\left(n_2\right)=-\infty$ and $V^{*}\left(c\right)=w_1+S$, with $n_2$ as the best free candidate.

The depth-2 variable-isolation template p fires when an $\mathtt{Eq}$ parent pairs with a $\mathtt{BvAdd}$ child, so $\sigma \left(n_1\right)\left[\mathtt{Eq}\right]=1$ while $\sigma \left(n_2\right)\left[\mathtt{Eq}\right]=0$.

At Position Eq (Figure 2b, left), the parent $n_{\mathrm{par}}=\mathtt{Eq}(c,c_k)$ computes $V^{\downarrow }\left(n_{\mathrm{par}}\right)=w_p+V^{\uparrow }\left(n_1\right)+V^{*}\left(c_k\right)=w_p+S+V^{*}\left(c_k\right)$ and $V^{-}\left(n_{\mathrm{par}}\right)=V^{*}\left(c\right)+V^{*}\left(c_k\right)=w_1+S+V^{*}\left(c_k\right)$ (since $w_1\left(n_{\mathrm{par}}\right)=0$). Since $V^{\downarrow }-V^{-}=w_p-w_1>0$, the trace-back selects state ↓, committing c to candidate $n_1$ in state ↑: the depth-2 gain $w_p$ outweighs the forgone depth-1 weight $w_1$ of $n_2$.

At Position BvUle (Figure 2b, right), the parent $n_{{\mathrm{par}}^{\prime }}=\mathtt{BvUle}(c,c^{\prime })$ finds no applicable depth-2 template ($V^{\downarrow }=-\infty$), so it selects state −, leaving c free. The trace-back selects $n_2=\mathtt{BvOr}$, which contributes its depth-1 weight $w_1$. The two decisions are independent: Position Eq selects $\mathtt{BvAdd}$ via state ↓ for the depth-2 match, while Position BvUle retains $\mathtt{BvOr}$ via state − for the depth-1 match. This outcome arises from DAG-to-tree unfolding, where each tree position is a separate subproblem with its own parent context.

5. Theoretical Analysis

This section establishes the two properties promised in Section 4: exactness of the optimum for template depth at most two, and polynomial time complexity.

5.1. Exactness for Bounded-Depth Templates

Proposition 1.

For any e-graph $\mathcal{G}$ and pattern template set $\mathcal{P}$ satisfying mutual exclusivity (Section 2.3) with ${max}_{p\in \mathcal{P}}{d}_p\le 2$, the output tree T produced by Algorithm 2 maximizes $CoverValue\left(T\right)$ as defined in Equation (1).

Proof. 

The argument establishes that the three-state DP computes an optimal tile covering on the output tree.

Step 1 (Exhaustive state coverage). Every output-tree node is assigned exactly one of the three states $\{-,\downarrow ,\uparrow \}$. The DP computes the optimal subtree value under each state (Equations (3)–(5)), and the trace-back (Algorithm 2) selects the best.

Step 2 (Mutual exclusivity). When n enters state ↓ with child $n_j^{\prime }$, the recurrence (Equation (5)) uses $V^{\uparrow }\left(n_j^{\prime }\right)$, which excludes any tile for $n_j^{\prime }$ itself. Conversely, when n is committed to state ↑ by its parent, $V^{\uparrow }\left(n\right)$ excludes any tile-root role for n. The $\downarrow \leftrightarrow \uparrow$ coupling thus correctly enforces non-overlapping tiles.

Step 3 (Optimal substructure). Processing in topological order ensures that all $V^{*}\left(c_i\right)$ values are finalized before any e-node referencing $c_i$ is processed. Each state’s value depends only on the subtree below n—the parent’s identity does not appear in Equations (3)–(5). The parent determines which state n enters, but not the optimal value within each state.

Step 4 (Trace-back exactness). Algorithm 2 selects at each e-class the candidate and state achieving the pre-computed optimum. DAG unfolding ensures that each tree position is an independent subproblem with its own parent context. No heuristic is involved.    □

The depth bound $d_p\le 2$ is essential: depth-3 templates would couple a node’s matching status to both its parent and grandparent, introducing inter-position dependencies that the three-state formulation cannot capture. This restriction aligns with observed practice: in compiler instruction selection, depth-two patterns constitute the dominant category (Blindell, 2016; Aho, Ganapathi & Tjiang, 1989), and in SMT preprocessing no template in our evaluation exceeds depth two.

5.2. Time Complexity

Let N denote the number of e-nodes, K the maximum arity, $\left|\mathcal{P}\right|$ the template set size, $C_{max}$ the maximum e-class size, and M the output tree size. Table 2 summarizes the cost.

The bottom-up pass visits each e-node once. For each e-node n, computing $w_1\left(n\right)$ and $\sigma \left(n\right)$ inspects templates in ${\mathcal{T}}_1$ and ${\mathcal{T}}_2$. Computing $V^{\uparrow }\left(n\right)$ and $V^{-}\left(n\right)$ costs $O\left(K\right)$. Computing $V^{\downarrow }\left(n\right)$ iterates over child positions (K), applicable templates ($\left|\mathcal{P}\right|$), and candidates within each child e-class ($C_{max}$), yielding $O(K·|\mathcal{P}|·C_{max})$ per e-node. Standard egg extraction runs in $O(N·K)$ (Willsey, Nandi,Wang, Flatt, Tatlock & Panchekha, 2021); the overhead is a factor of $\left|\mathcal{P}\right|·C_{max}$, both moderate constants in practice.

The top-down pass visits each of the M output-tree nodes once, reading the pre-computed decision at $O\left(K\right)$ cost per node. No template evaluation occurs during trace-back. The combined worst-case complexity is $O(N·K·|\mathcal{P}|·C_{max}+M·K)$, dominated by the bottom-up pass. When $C_{max}$ is bounded, this simplifies to $O(N·K·|\mathcal{P}\left|\right)$.

6. Experiments

6.1. Experimental Setup

The evaluation targets the extraction algorithm in isolation—its coverage quality, correctness, and runtime—rather than end-to-end application performance. All experiments are implemented in Rust atop egg 0.11 (Willsey, Nandi, Wang, Flatt, Tatlock & Panchekha, 2021); the three extraction strategies share the same e-graph representation and template infrastructure so that observed differences are attributable solely to the extraction logic. The DP computation uses fixed-point iteration, equivalent to topological-order processing, which naturally handles cycles arising from identity-absorbing rewrites.

Benchmarks. Two benchmark categories are used. SMT-COMP verification formulas (21 instances) are drawn from the QF_BV and QF_ABV divisions of the 2024 SMT-COMP library (Barrett, Fontaine & Tinelli, 2017), originating from hardware verification workloads (PicoRV32, VexRiscv, ZipCPU, arbiter). Each formula is saturated with an iteration budget of 10 and a node limit of ${10}^5$; resulting e-graphs range from ${10}^4$ to $2.4\times {10}^5$ e-classes with $C_{max}=2$–4. Of these, 13 instances have operator compositions intersecting the template set ($CoverValue>0$); Table 3 reports the 10 distinct coverage profiles (three further instances from the same families yield identical ratios and are omitted). The remaining 8 instances contain exclusively non-template operators. Synthetic benchmarks (3 instances, 15–80 assertions) embed known depth-2 patterns (mask-shift, high-mask equality, addition-equality isolation) alongside depth-1 patterns in QF_BV formulas; after saturation they contain 88–378 e-classes. A third set of micro instances (29–35 e-classes) supports brute-force correctness verification (Section 6.3).

Templates and strategies. The template set comprises three depth-1 templates (weights 3–5) and three depth-2 templates (weights 12–14) satisfying the super-additivity constraint of Section 2.2; $\left|\mathcal{P}\right|=6$. Three strategies are compared: standard extraction (AST-size minimization (Willsey, Nandi, Wang, Flatt, Tatlock & Panchekha, 2021)), depth-1 only (Algorithm 1 with $V^{\downarrow }$ disabled), and full three-state (Algorithms 1–2). ILP (Tate, Stepp, Tatlock & Lerner, 2009) is excluded for the structural reasons analyzed in Section 7.

6.2. Extraction Quality

Pattern awareness vs. standard extraction. Table 3 compares $CoverValue\left(T\right)$ across the three strategies. On the VexRiscv and bv-format benchmark families, pattern-aware extraction (both depth-1-only and full three-state) yields $16\times$–$31\times$ higher CoverValue than standard AST-size extraction. On PicoRV32 instances, the dominant operators do not intersect any template, and all strategies yield identical CoverValue. These results confirm that pattern awareness captures optimization value inaccessible to decomposable size-based cost functions, with the magnitude scaling with the density of template-matchable operators in the workload.

Depth-2 ablation. Table 4 isolates the incremental contribution of the $V^{\downarrow }$ mechanism on the synthetic benchmarks, which are designed with sufficient depth-2 pattern density to exercise the three-state DP. The full strategy improves CoverValue by 45–$51\%$ over the depth-1-only baseline, with depth-2 tile hits increasing from 6–28 (incidental matches under depth-1 optimization) to 10–50 (intentional matches under the three-state DP). In the BURS instruction selection literature, tree covering algorithms are evaluated independently of the instruction set architecture (Blindell, 2016; Pelegri-Llopart & Graham, 1988; Aho, Ganapathi & Tjiang, 1989): correctness and complexity are algorithmic properties, while the coverage achieved on a given workload depends on the pattern vocabulary. Following the same separation, the synthetic benchmarks validate the $V^{\downarrow }$ mechanism itself; developing comprehensive depth-2 template vocabularies tuned to specific workloads is orthogonal to the algorithmic contribution and is left to future work.

6.3. Correctness Validation

A brute-force enumerator traverses all feasible extraction trees on the micro instances and computes the globally optimal CoverValue by exhaustive search. Table 5 reports the results: the three-state algorithm matches the brute-force optimum on all three instances, empirically confirming the exactness guarantee of Proposition 1 and validating the implementation.

6.4. Runtime Efficiency

Table 6 reports wall-clock extraction time. The full three-state strategy incurs $1.9$–$2.8\times$ overhead relative to standard extraction on SMT-COMP benchmarks, with the fixed-point DP computation dominating ($>85\%$ of total time). This is consistent with the theoretical $\left|\mathcal{P}\right|·C_{max}$ factor of Section 5.2: with $\left|\mathcal{P}\right|=6$ and $C_{max}\le 4$, each child position inspects at most 24 candidate–template pairs, a modest cost amplified by the number of fixed-point iterations. On synthetic benchmarks, all strategies complete in under two milliseconds. The absolute time on the largest instance (2.7 s on zipcpu-pfcache, $2.4\times {10}^5$ e-classes, 500 roots) exceeds the saturation phase (89–265 ms on the same instances), reflecting the cost of multi-root formula processing; the DP phase itself is a one-time cost independent of the number of roots.

7. Related Work

The extraction problem in equality saturation has grown in importance as e-graphs have been applied to compilers (Joshi, Nelson & Randall, 2002; VanHattum, Nigam, Lee, Bornholt & Sampson, 2021), SMT solvers (Flatt, Coward,Willsey, Tatlock & Panchekha, 2022), hardware verification (Coward, Constantinides & Drane, 2023), and manufacturing (Nandi et al., 2020). The standard extraction algorithm implemented in the egg framework (Willsey, Nandi,Wang, Flatt, Tatlock & Panchekha, 2021) performs a single bottom-up traversal that greedily selects the candidate minimizing a decomposable, single-node cost function such as abstract syntax tree size. This approach is efficient and provably optimal when costs decompose additively over individual nodes, but it cannot express objectives that depend on multi-node structural context. Earlier, Joshi, Nelson and Randall (2002) used e-graphs in the Denali superoptimizer to generate optimal code via goal-directed search, demonstrating the potential of e-graphs for program optimization; however, Denali does not formalize an extraction-time objective. To handle more general, non-decomposable cost functions, Tate, Stepp, Tatlock and Lerner (2009) formulated extraction as an integer linear program (ILP), enabling global optimality at the expense of NP-hard worst-case complexity that limits scalability to large e-graphs. Our work is complementary: rather than targeting arbitrary cost functions with a general-purpose solver, we identify a structured class of objectives—bounded-depth weighted pattern coverage—and exploit this structure to obtain an exact, polynomial-time algorithm.

Beyond computational cost, the ILP formulation exhibits a structural limitation for the weighted pattern cover objective. The ILP encoding of  Tate, Stepp, Tatlock and Lerner (2009) assigns one binary variable per (e-class, e-node) pair, enforcing a global selection that cannot express position-dependent decisions when a shared e-class appears under parents with differing contextual requirements. The pattern cover objective is therefore structurally incompatible with the ILP formulation: the gap lies in the distinction between global selection and position-dependent selection, which DAG-to-tree unfolding (Section 4.1) resolves.

A closely related line of work originates from compiler instruction selection, where the tree covering problem seeks to partition a fixed expression tree into non-overlapping tiles matching instruction patterns at minimum total cost. Aho, Ganapathi and Tjiang (1989) formalized code generation as tree matching with dynamic programming, and Pelegri-Llopart and Graham (1988) established the BURS (Bottom-Up Rewrite System) framework with offline automaton compilation (Proebsting, 1995); both achieve optimal tree covering via bottom-up dynamic programming when the input is a fixed tree. However, extending tree covering from trees to DAGs—as required when expression DAGs contain shared subexpressions—renders the problem NP-complete (Blindell, 2016). Practical compilers such as GCC and LLVM therefore resort to unfolding DAGs into trees before applying instruction selection (Koes & Goldstein, 2008). Our algorithm adopts the same unfolding principle but applies it to the AND-OR DAG structure of e-graphs, where each e-class (OR node) introduces candidate selection on top of the standard tile assignment problem. This additional degree of freedom necessitates a three-state DP—the minimal extension of classical BURS that explicitly tracks the tile-leaf role arising from depth-2 mutual exclusivity. When the e-graph degenerates to a single-candidate-per-class tree, the algorithm reduces to standard BURS. To our knowledge, no prior work has migrated tree covering techniques to the e-graph extraction setting or formalized the weighted pattern cover objective on AND-OR DAGs.

8. Conclusions

This paper formalized pattern-aware extraction from e-graphs as a weighted pattern cover problem on AND-OR DAGs and identified three challenges—OR-node annotation ambiguity, context-dependent selection, and DAG sharing conflict—that distinguish this setting from classical tree covering. Exploiting the tree-shaped nature of the extraction output, we designed an algorithm based on three-state tree DP—generalizing BURS tree covering from fixed trees to AND-OR DAGs—that computes an exact optimum for bounded-depth templates in $O(N·K·|\mathcal{P}|·C_{max})$ time. Experiments on SMT-COMP hardware verification benchmarks demonstrate that pattern-aware extraction improves weighted coverage by up to $31\times$ over standard AST-size extraction; an ablation study on synthetic benchmarks further confirms that the depth-2 tiling mechanism contributes an additional 45–$51\%$ improvement when depth-2 template opportunities are present, with extraction overhead remaining within a factor of 2–$3\times$ relative to standard extraction.

Several directions remain for future investigation. Extending the framework to templates of depth three or beyond would require additional DP states and a careful analysis of the resulting inter-position coupling. Integrating pattern-aware extraction with the saturation phase itself—for instance, by guiding rewrite rule application toward regions where high-value templates are likely to match—could further improve overall optimization quality. Finally, evaluation on a broader range of application domains, including compiler middle-end optimization (VanHattum, Nigam, Lee, Bornholt & Sampson, 2021) and hardware synthesis (Coward, Constantinides & Drane, 2023), would help characterize the generality of bounded-depth pattern coverage as an extraction objective.