Extended Algebraic Decision Diagrams (XADD)

• XADDs are canonical, compact, directed acyclic graphs that represent piecewise polynomial functions over mixed Boolean and real-valued domains.
• They support both Boolean tests and continuous linear inequality tests, enabling exact symbolic dynamic programming for hybrid MDPs.
• XADDs optimize space and runtime through canonical reductions, DAG sharing, and bounded-error compression, scaling to complex, high-dimensional decision problems.

An Extended Algebraic Decision Diagram (XADD) is a canonical, compact, rooted, directed acyclic graph data structure for symbolically representing piecewise polynomial functions over mixed Boolean and real-valued vector domains. XADDs generalize Algebraic Decision Diagrams (ADDs) by supporting both Boolean variable tests and continuous linear inequalities at decision nodes, and by allowing arbitrary polynomial (or more generally algebraic) leaf expressions. XADDs have become the central data structure enabling exact or bounded-approximate symbolic dynamic programming (SDP) for Markov Decision Processes (MDPs) with mixed discrete and continuous state spaces, supporting complex piecewise-partitioned value functions and enabling closed-form operations on high-dimensional functions (Sanner et al., 2012, Vianna et al., 2013).

1. Formal Structure and Semantics

An XADD represents a function $$f(b, x): \{0,1\}^n \times \mathbb{R}^m \rightarrow \mathbb{R}$$ using a combination of decision nodes and terminal expression leaves. Each internal (decision) node corresponds either to:

• a Boolean variable test $b_i?$,
• or a continuous linear inequality test $\alpha^\top x + \beta \ge 0$ (or, equivalently, $\leq 0$, $< 0$).

Each path from the root to a leaf encodes a conjunction of decisions, collectively describing a region of the input space—a (potentially non-rectangular) convex polytope for continuous variables, possibly restricted by the Boolean assignment. Each leaf node contains a real-valued algebraic expression, most commonly an affine (linear) or polynomial function in $x$.

The semantics are as follows: evaluation starts at the root and traverses the XADD according to the variable assignments and evaluations of the linear inequalities until a leaf is reached. The function's value is then given by the leaf expression for inputs consistent with the path predicates.

The recursive case form is

$$f(b, x) = \begin{cases} f_1(x) & \text{if } \phi_1(b, x) \ \vdots \ f_k(x) & \text{if } \phi_k(b, x) \end{cases}$$

where each partition $\phi_i(b, x)$ defines disjoint, exhaustive piecewise regions.

XADDs are canonical under a total test ordering and three reductions:

• R1: Redundant-test elimination (if both children identical, drop the node).
• R2: Isomorphic subgraph merging (identical test and children → merge nodes).
• R3: Duplicate terminal merging (identical algebraic leaf → merge) (Sanner et al., 2012).

2. Canonical Reductions, Maintenance, and Pruning

A unique, minimal XADD representation for a function is achieved with strict test ordering and recursive application of the three reduction rules:

• Path test order: all Boolean variables precede all continuous inequalities, and inequalities are well-ordered (e.g., lexicographically on coefficients, constants).
• DAG-based sharing: subfunctions corresponding to identical decision logic and outcomes are stored once and referenced multiple times.
• Constraint-based pruning: infeasible regions implied by inconsistent test sequences are eliminated via LP-feasibility checks on the conjunction of path inequalities (Sanner et al., 2012).

Pruning not only shrinks the representation but dramatically accelerates manipulation by discarding subgraphs that cannot contribute to the function value over any legal input.

3. Primitive XADD Operations

Efficient symbolic dynamic programming with XADDs hinges on a set of recursive DAG operations, each preserving canonical structure:

• Apply: Pointwise binary operations (addition, subtraction, multiplication, max) induced via recursive traversal, aligning test orders in a zip-like fashion. For example, $\text{APPLY}(+, F, G)$ returns $H = F + G$ as an XADD.
• Restrict: Conditional fixing of a Boolean or continuous test, used for summing or marginalizing over variables.
• Substitute: Symbolic replacement of variables by functions (e.g., Dirac deterministic integration corresponds to substitution for state transitions).
• Maximization: Implements partition-wise maximization. For $H(x) = \max(F(x), G(x))$, new inequality tests such as $F(x) - G(x) > 0$ partition the domain.
• Continuous Integration: For Dirac-delta transition models, reduces to case-wise substitution on regions defined by indicator functions.
• Marginalization over Discrete Variables: Via restriction and summation over possible Boolean assignments.

All primitive operations invoke reduction to guarantee canonical forms and recursive readjustment of test orders as required.

A summary of core XADD manipulation operations is shown below:

Operation	Purpose	Implementation Sketch
Apply	Pointwise binary op	Align test orders, recurse, reduce
Restrict	Fix a test to true/false	Traverse adding trivial decision
Substitute	Replace var with expression	Rewrites tests, leaves, reduces
Max	Pointwise maximization	Partition with inequality comparisons
Integrate	Dirac-delta integration	Substitution and indicator application

(Sanner et al., 2012, Vianna et al., 2013)

4. XADD in Symbolic Dynamic Programming for Hybrid MDPs

XADDs form the backbone of exact symbolic dynamic programming for hybrid discrete-continuous MDPs (DC-MDPs). The SDP process for finite-horizon DC-MDPs involves iterative computation of $V_{h+1}(b, x)$:

1. Bellman backup: Compute action-value $Q_{h+1}(b, x, a)$ as a sum of reward, discounted expectation (Boolean sum, continuous substitution per Dirac representation), and maximization over actions.
2. Integration via Dirac-delta: The transition model $P(x'|...)=\delta[x'-T(b, x, a)]$ prompts substitution $x' \leftarrow T(b, x, a)$ in the value XADD.
3. Discrete sum: Performed as repeated restriction over all values of Boolean successor variables, summing corresponding weighted value XADDs.
4. Action maximization: Repeated application of partition-wise maximization over Q functions encoded as XADDs.

Each operation coincides directly with one of the XADD primitives, enabling closed-form, combinatorially concise value iteration for domains containing arbitrary polynomial piecewise partitions with non-rectangular boundaries (Sanner et al., 2012).

5. Bounded-Error Compression for XADDs

Despite the compactness achieved by reductions and pruning, exact XADD-based SDP may still scale poorly as the number of partitions grows exponentially with horizon and problem dimensionality. Bounded-error XADD compression (XADDComp) introduces a principled trade-off:

• Given a global error threshold $\varepsilon$, the algorithm successively merges pairs of leaves—each corresponding to affine (or polynomial) expressions over adjacent regions—whenever their merger induces a maximum error not exceeding $\varepsilon$. The task, for leaf functions $f_1(x)$ on region $\phi_1$ and $f_2(x)$ on $\phi_2$, is to find an aggregated function $f^*(x)$ such that

$$\varepsilon^* = \min_{c^*} \max_{i\in\{1,2\}} \max_{x\in \phi_i} |f_i(x) - f^*(x)|$$

• This requires solving a constrained bilinear saddle-point problem, which reduces to a sequence of linear programs over the convex polytopes defined by the original partition predicates, using a constraint-generation technique for optimal, finite-time solution (Vianna et al., 2013).

Algorithmically:

Algorithm 1: XADDComp(XADD X, ε) → (X',e) Initialize all leaf-errors to 0; open list of leaves. while open ≠ ∅: for all pairs of leaves (L1, L2) in open: (f*, δ) ← PairLeafApp(L1, L2) if max(L1.err, L2.err, δ) ≤ ε: Merge, update error counters, simplify XADD break return (X', max leaf error)

PairLeafApp solves for $f^*$ by constraint generation:

• Master LP for $(c^*, \varepsilon)$, separation LPs to identify extremal points on each region, iteratively tightening the bounds.

The result is a shrunk XADD with a rigorously bounded deviation from the original, with empirical reductions in node count by an order of magnitude on benchmark domains, and runtime speedups up to 20× for moderately loose $\varepsilon$ (Vianna et al., 2013).

6. Complexity, Scalability, and Memory Trade-Offs

In the worst case, the number of XADD nodes grows exponentially, proportional to the number of independent decision boundaries (tests) required to partition the input domain. Each primitive operation has time complexity $O(|F|\cdot|G|)$ in the sizes of the argument XADDs, but DAG sharing and memoization ensure practical efficiency.

Constraint-based pruning exploits infeasibility in the partition conjunctions, skipping unreachable subgraphs through LP feasibility checks, which is critical as problem size and number of constraints increase. Memory sharing arises naturally, as isomorphic subgraphs and duplicate terminal expressions are merged at construction, substantially improving scalability.

With bounded-approximate compression (BASDP), dramatic reductions in size and runtime are achieved with a user-specified error bound $\varepsilon$:

• Space: typically yields $5$–$20\times$ fewer nodes for $\varepsilon=0.05$.
• Time: up to $10\times$ speedup per value-iteration step.
• Empirical error: actual value loss sharply lower than pessimistic $H\varepsilon$ bounds (often around $30$–$50\%$ of the bound) (Vianna et al., 2013).

7. Applications and Impact

XADDs enable the representational and algorithmic leap required for optimal solutions to DC-MDPs with general piecewise-linear or piecewise-polynomial value and transition functions, far surpassing early approaches limited to rectangular or purely discrete domains. Application examples include robotics (Mars rover path planning), inventory management, and other hybrid systems where state and action variables span discrete and continuous spaces with intricate, high-dimensional conditional structure (Sanner et al., 2012, Vianna et al., 2013).

In summary, XADDs provide a principled, lossless or bounded-approximate approach to symbolic reasoning over mixed Boolean-continuous domains, forming the computational bedrock for SDP in hybrid systems, and opening the door to previously intractable classes of sequential decision problems.