Subgraph-based Sequentialization

• Subgraph-based sequentialization is a method that decomposes complex graph structures into meaningful sequences by identifying key subgraph components.
• It employs techniques like split node decomposition, empires, and meta-switching to ensure valid logical proof derivations and efficient computation.
• Recent advances, including RL-QVO models, demonstrate significant runtime improvements and robust performance in both proof systems and subgraph matching.

Subgraph-based sequentialization refers to techniques that structurally decompose complex graph-based entities (such as proof-graphs or query graphs) into sequences by identifying and exploiting meaningful subgraph structures. These techniques play a critical role both in the theory of proof systems and in the efficient processing of graph algorithms, notably in logical sequentialization and subgraph matching. This entry covers foundational definitions, algorithmic frameworks, key theoretical results, and state-of-the-art applications as established by recent work on N-Graphs sequentialization (Carvalho et al., 2018) and learning-based subgraph sequentialization for matching (Wang et al., 2022).

1. Formal Definitions and Core Structures

N-Graphs are finite directed graphs whose nodes are labeled by formula occurrences, with edges divided into solid and meta (labeled “m”) types. Each node serves as premise or conclusion of at most one link. Links are categorized as:

• Logical Links: Representing logical rules such as ⊤, ⊥, ∧–I, ∧–E, ∨–I, ∨–E, ¬–I, ¬–E.
• Structural Links: Including weakening, contraction, expansion.
• →–I links: Special natural deduction style, with meta-edges from discharged hypotheses.

Links are classified as focusing (2 premises to 1 conclusion) or defocussing (1 premise to 2 conclusions); expansion and contraction are “switchable,” allowing edges to be deleted in meta-switchings.

Meta-switching involves, for each expansion or contraction link, deleting one of its two edges; and for each meta-edge (of a →–I), choosing its attachment. An N-Graph is valid (a correct proof-net) iff all meta-switchings yield connected, acyclic graphs (the Danos–Regnier criterion).

Sub-N-Graphs are subgraphs that themselves are valid N-Graphs, with certain vertices (doors) designated as upper or lower depending on their role as premise or conclusion. Subgraph structure is fundamental for sequentialization.

2. Subgraph-based Sequentialization in Logic: Full N-Graphs

The sequentialization theorem for full propositional classical N-Graphs asserts that any such N-Graph (with premises $A_1, \dots, A_n$ and conclusions $B_1, \dots, B_m$) can be mapped to a cut-free sequent-calculus derivation in LK for $A_1, \dots, A_n \vdash B_1, \dots, B_m$, preserving each occurrence's role. This mapping is enabled by a recursive subgraph-based decomposition (Carvalho et al., 2018).

The construction relies on identifying a split node $A$, producing two key sub-N-Graphs:

• North-empire $eA^\wedge$: Largest sub-N-Graph with $A$ as lower door.
• South-empire $eA^\vee$: Largest with $A$ as upper door. The kingdom $wA = eA^\wedge \cup eA^\vee$ is used to define a strict partial order $A \ll B$ iff $wA \subsetneq wB$. Maximal $A$ in this order yield a partition of the graph at $A$, supporting recursive decomposition.

The sequentialization proceeds as follows:

1. Base: For a singleton node, derive $A \vdash A$ directly.
2. Structural links (expansion, contraction, →–I): Map via left/right contraction or implication introduction rules.
3. Otherwise, use the maximal $A$ to split at $wA$, recursively sequentize $eA^\wedge$ and $eA^\vee$, and apply a single cut to reconstruct the entire derivation.

Empires and kingdoms are closed under twelve specific link-closure conditions, ensuring well-defined, canonical sub-N-Graphs at each splitting stage. The process supports polynomial-time transformation and enables efficient sequentialization checks (Carvalho et al., 2018).

3. Subgraph-based Sequentialization in Subgraph Matching

In subgraph matching, the enumeration of all isomorphic embeddings of a query graph $q$ in a data graph $G$ is highly sensitive to the order in which query vertices are matched. Recent advances formulate the generation of efficient matching orders as a subgraph-based sequentialization or query-vertex ordering problem (Wang et al., 2022).

The RL-QVO model casts this as a finite-horizon Markov decision process (MDP), where at each step $t$:

• The state $s_t$ includes the partial order $\phi_t$ and a feature matrix $H_q^t$ encoding both static and dynamic graph properties (degrees, label ratios, ordered indicators).
• The action selects the next query vertex to order, constrained to those adjacent to already-ordered ones.
• The transition updates the ordering and dynamic features.
• The reward combines enumeration reduction (relative to a baseline ordering), local validity checks, and entropy for exploration, aggregated with exponential time decay.

A graph convolutional network (GCN) processes per-vertex features and outputs an action policy over candidate vertices, parameterized by a GCN+MLP architecture.

4. Algorithmic Frameworks and Optimization

In the RL-QVO framework:

• The policy $\pi_\theta$ is trained with Proximal Policy Optimization (PPO), using the clipped surrogate objective for robust improvement.
• Training leverages an incremental schedule: initial epochs use small query graphs, with later fine-tuning on larger graphs.
• At test time, ordering is efficient: per-query time is $O(|V(q)|\cdot (|E(q)| + d^2))$, and a greedy policy produces the order by repeated forward passes through the trained GNN.

This method yields matching orders (sequentializations) that minimize unnecessary enumeration during subgraph matching, dramatically improving query runtime (Wang et al., 2022).

5. Theoretical Results and Technical Lemmas

The logical sequentialization method is underpinned by several technical results (Carvalho et al., 2018):

• Empire existence and closure: Empires are the intersection over all meta-switchings or the closure under specified link operations.
• Nesting Properties: Nestedness of empires supports the partial order $A\ll B$, with terminal links enforcing constraints on this order.
• Correctness: Split-and-reassemble steps preserve the DR-criterion, ensuring each sub-N-Graph remains valid for recursive sequentialization.
• Union Lemma: The union of north-empire and south-empire at $A$ forms a legitimate sub-N-Graph (the kingdom).

In the RL-based formulation, empirical ablation demonstrates that the structural (GNN) and dynamic (entropy/validation reward) elements substantially outperform purely heuristic or non-neural approaches. Replacing the GCN by GAT or GraphSAGE's GNNs maintains performance robustness (Wang et al., 2022).

6. Computational Complexity and Experimental Evidence

Empirical and analytical results establish the computational efficacy of subgraph-based sequentialization methods:

• In N-Graphs, all kingdoms can be computed in $O(L\cdot V)$ steps, with overall sequentialization in near-linear time in practice (Carvalho et al., 2018).
• RL-QVO achieves per-query orders of magnitude speedups—100x–200x—over classical and state-of-the-art unordered and heuristic-based baselines on large real-world graphs, while maintaining low model size (~186 kB) and typically returning no unsolved (timed-out) queries where prior models fail (Wang et al., 2022).

Ablation reveals dramatic slowdowns without the GNN or handcrafted features, or if policy regularization (entropy/validation reward) is omitted.

7. Illustrative Example and Application Domains

An N-Graph example for $$\vdash (A\wedge B), (\neg A \lor \neg B)\wedge D, \neg D$$ demonstrates the split-node decomposition: computing kingdom sets, finding the maximal formula (the →–I conclusion), extracting north/south empires, and composing the LK sequent derivation with a single cut at the split formula (Carvalho et al., 2018).

In subgraph matching, RL-QVO is validated on diverse real-world datasets (Citeseer, Yeast, DBLP, Youtube, Wordnet, EU2005) with varying query sizes. Across the board, RL-QVO nearly eliminates query timeouts and significantly reduces enumeration counts, confirming the utility of learned sequentializations in practical applications (Wang et al., 2022).