Decompose-and-Formalise Framework Overview

• Decompose-and-Formalise Framework is a rigorous methodology that decomposes complex Boolean functions into simpler, well-specified components with formal reconfiguration constraints.
• It employs bounded-width OBDDs and second-order automata to symbolically represent and verify resource limits and functional correctness at each circuit gate.
• The framework utilizes a fixed-parameter, linear-time synthesis algorithm to ensure all intermediate computations meet strict complexity and resource specifications.

A Decompose-and-Formalise Framework is a rigorous methodology for structurally breaking down complex systems, functions, or tasks into compositions of simpler, well-specified components, with subsequent formal reasoning about the correctness or feasibility of these decompositions. This article presents the theoretical foundation, symbolic machinery, algorithmic methods, and complexity results associated with the Decompose-and-Formalise approach in the context of Boolean functional decomposition and its generalizations, as systematized by "Symbolic Functional Decomposition: A Reconfiguration Approach" (Oliveira et al., 13 Jan 2026).

1. Functional Decomposition and Reconfiguration

Classically, Boolean functional decomposition seeks, given a target function $f : \{0,1\}^n \rightarrow \{0,1\}$, an expression

$f = g(f_1, \ldots, f_k)$

for functions $f_i : \{0,1\}^n \to \{0,1\}$ and an outer function $g : \{0,1\}^k \to \{0,1\}$, typically with each $f_i$ drawn from some restricted class $\mathcal{F}$ (for example, low complexity, low width, or obeying other resource constraints). This composition can also be viewed as the evaluation of a Boolean circuit $G$ (computing $g$), with the $f_i$ as inputs.

The Decompose-and-Formalise framework strengthens decomposition to reconfiguration: not only must the factor functions $f_i$ be in $\mathcal{F}$ (or respect resource bounds), but so must every intermediate function computed at each gate in the circuit $G$. Explicitly, for gates $g_1, \ldots, g_m$ in $G$ (topologically ordered), if $F_{g_j}(f_1, \ldots, f_k)$ denotes the function realized at $g_j$, then the reconfiguration constraint is

$$\forall j:\quad F_{g_j}(f_1,\ldots,f_k) \in \mathcal{F}$$

or, alternatively, each intermediate must respect a fixed symbolic representation budget.

2. Symbolic Representation via OBDDs and Automata

To enforce class constraints symbolically, the framework adopts Ordered Binary Decision Diagrams (OBDDs) of bounded width for function representation. For $h:\{0,1\}^n \to \{0,1\}$, the OBDD is a sequence $D = B_1 B_2 \cdots B_n$ over the OBDD layer alphabet $\widehat{B}(w)$, with transitions encoding function evaluation. The width of an OBDD is the maximum number of nodes per layer, and size is the total number of nodes.

The set of functions accepted is denoted $f_D(x) = 1$ if $D$ accepts $x$, $0$ otherwise. Every OBDD admits a canonical minimal form $C(D)$ (unique normalized OBDD of minimum width and size, accepting the same function), enabling succinct equivalence and resource analysis.

A second-order finite automaton $\mathcal{A} = (Q, I, F, \delta)$ over $\widehat{B}(p)$ recognizes the class $\mathcal{F}$ by accepting only those OBDDs (of width $\leq p$) satisfying functional and resource constraints. Standard automata-theoretic operations—intersection, complementation, inclusion testing—are available for automata on OBDDs.

3. Circuit-based Formalisation of Reconfiguration

The outer function $g$ is realized by a Boolean circuit $G$ with $k$ inputs and $m$ gates (of bounded depth and fan-in), evaluated over the OBDD-represented $f_i$. The reconfiguration width $w(G, f_{D_1}, ..., f_{D_k})$ is defined as the maximal width among canonical OBDDs for all intermediate gate functions in $G$, that is,

$$w(G, f_{D_1}, ..., f_{D_k}) = \max_{1 \leq j \leq m} w(C(F_{g_j}(f_{D_1}, ..., f_{D_k})))$$

This definition captures both structural and resource-complexity restrictions on the allowed decompositions.

4. Algorithmic Synthesis and Complexity

The key theoretical result is a fixed-parameter, linear-time algorithm for the reconfiguration-decomposition problem: Given

• an input OBDD $D$ (length $n$, width $w_D$) representing $f$,
• a reconfiguration circuit $G$ (size $m$, inputs $k$),
• a second-order automaton $\mathcal{A}$ recognizing $\mathcal{F}$,

decide whether there exist OBDDs $D_1, \ldots, D_k$ (width $\leq p$, accepted by $\mathcal{A}$) such that

$$D = G(D_1, ..., D_k) \quad \text{and} \quad w(G, f_{D_1}, ..., f_{D_k}) \leq w$$

The membership algorithm constructs a product automaton that simulates all constraints—class inclusion, gate-by-gate width, final function equivalence—in $O(2^{O(m w^2 \log w)}\, |\mathcal{A}|^k\, n)$ time. For fixed $k, p, m, |\mathcal{A}|$, this is linear in the input size $n$, making such decompositions tractable for bounded-parameter regimes (Oliveira et al., 13 Jan 2026).

5. Formal Framework: Automata-Theoretic Synthesis

The Decompose-and-Formalise process consists of three symbolic manipulations:

1. Decomposition Step: Choose a small circuit $G$ (parameters $k,m,d$) and interpret each decomposition $f = G(f_1, \ldots, f_k)$ as a reconfiguration over bounded-width OBDDs.
2. Symbolic Formalisation: Encode input and all intermediates as OBDDs of width $\leq w$; represent the function class $\mathcal{F}$ as a second-order automaton $\mathcal{A}$; and utilize "selector" automata to enforce that each circuit gate maintains the right symbolic/functional properties.
3. Complexity Analysis via Product Automata: Unite the constraints via an automata product construction—multiply one copy of $\mathcal{A}$ for each input $D_i$, combine with gate-wise automata, append a canonical-OBDD check for the output, and intersect with the singleton language $\{D\}$. The resulting automaton is bounded in size by $2^{O(m w^2 \log w)} |\mathcal{A}|^k n$ and can be tested for nonemptiness in linear time in $n$.

This yields a uniform synthesis template adaptable to any symbolic representation (OBDDs of bounded width), any reconfiguration circuit, and any automata-representable functional class.

6. Applications, Implications, and Extensions

The generality of this Decompose-and-Formalise architecture supports a wide spectrum of symbolic synthesis and verification tasks, including:

• Synthesis of functional decompositions under explicit resource constraints.
• Verification that all intermediates in a composition reside within a desired symbolic or semantic class.
• Design of modular, compositional synthesis tools based on automata and symbolic representations.

The approach leverages automata-theoretic closure properties for compositional reasoning and supports further extensions (e.g., richer OBDD alphabets, circuit classes, alternate symbolic representations).

A plausible implication is that similar symbolic and automata-theoretic methods can be adapted for more general classes of functions, or even non-Boolean settings, provided their representations and composition operations are suitably tractable.

7. Summary and Theoretical Guarantees

The Decompose-and-Formalise framework, as formalized in (Oliveira et al., 13 Jan 2026), provides:

• Canonical, automata-theoretic representations for both functions and their classes.
• A precise circuit-based formalization of functional reconfiguration with fine-grained control over all intermediate steps.
• Algorithmic synthesis and verification of decompositions with strict resource and semantic constraints.
• A fixed-parameter linear-time solution for the main decision problem, given appropriately bounded parameters.
• Compositionality, closure, and decidability results via automata theory, ensuring soundness, completeness, and extensibility.

This body of results establishes a theoretically robust and practically efficient foundation for symbolic reconfiguration and functional decomposition in Boolean settings, and provides a blueprint for automata-based synthesis in broader domains (Oliveira et al., 13 Jan 2026).