Dynamic Kernelization Algorithms

• Dynamic kernelization algorithms are dynamic methods that reduce NP-hard problems to smaller, equivalent kernels through local updates.
• They leverage techniques such as protrusion decomposition, dynamic sampling, and approximate solution maintenance for efficient, sublinear-time updates.
• These algorithms facilitate real-time processing in evolving graphs and hypergraphs, bridging static kernelization with dynamic fixed-parameter tractability.

Dynamic kernelization algorithms are dynamic data structures and update protocols that maintain compact problem kernels—small equivalent instances—under sequences of local changes (such as edge insertions and deletions) to highly combinatorial objects like graphs, hypergraphs, or temporal networks. These algorithms extend the classical kernelization paradigm from static preprocessing into the fully dynamic setting, supporting efficient amortized update times and enabling real-time fixed-parameter tractability (FPT) for $\mathsf{NP}$-hard problems. The development of dynamic kernelization interweaves concepts from parameterized complexity, data structure design, structural graph theory (notably, protrusion decompositions and bounded treewidth techniques), and dynamic programming.

1. Foundations and Definitions

Dynamic kernelization algorithms generalize the standard notion of kernelization by maintaining a polynomial-time (often linear) reduction of a dynamically changing input instance to an equivalent smaller instance whose size is bounded by a function of the parameter (but independent, or nearly independent, of the input size $n$). The essential structural property is the ability to support local modifications—typically insertions and deletions of edges, vertices, sets, or elements—in time sublinear in $n$, while ensuring that the reduced instance ("kernel") can be efficiently updated and continues to reflect the original problem's optimum.

Formally, for a parameterized problem $(I, k)$, a dynamic kernelization algorithm maintains a data structure such that:

• At all times, the reduced instance $I'$ is equivalent to $I$ (for decision or optimization purposes), and $|I'| \leq h(k)$ for some function $h$.
• Each explicitly supported update (e.g., edge insertion/deletion) can be processed in time $f(k) \log^{O(1)} n$ (sometimes $f(k)$), where $f$ is computable but may be exponential or superpolynomial in $k$.
• Queries (such as reporting an optimal solution or verifying the parameterized property) can be answered in time $g(k) \log^{O(1)} n$.

The focus is on fully dynamic settings, supporting arbitrary interleaving sequences of additions and removals.

2. Algorithmic Frameworks and Techniques

Dynamic kernelization exploits several algorithmic strategies, including:

• Dynamic Protrusion Decomposition: A central advance is the maintenance of protrusion decompositions under dynamic changes, enabling the substitution of large, bounded-treewidth substructures ("protrusions") with precomputed small gadgets that preserve problem-specific properties. The decomposition is dynamically updated using superbranch decompositions and structural invariants ensuring small bag sizes, bounded adhesions, and logarithmic depth (Bertram et al., 5 Nov 2025).
• Dynamic Sampling and Hashing: For fine-grained streaming models, randomized (pairwise-independent) hashing and color-coding primitives maintain small subgraph kernels by sampling representatives for low-parameter or structure-rich regions (such as low-degree vertices or sparse edge neighborhoods), supporting additive and multiplicative approximations (Chitnis et al., 2015).
• Approximate Solution Maintenance: Many algorithms maintain an $O(1)$-approximate solution at all times, repairing it locally after each update. A kernel is then extracted based on this approximation. For classical problems like Vertex Cover, Cluster Vertex Deletion, and Feedback Vertex Set, this leads to poly($k$)‐sized kernels recoverable in polylog($n$) amortized time (Iwata et al., 2014).
• Dynamic Programming–Based Protrusion Replacement: Problems amenable to expressive DP encodings admit constructive replacements for dynamic protrusions, using finite-index equivalence relations at bag boundaries and efficiently computed small representatives (Garnero et al., 2013).

A generic dynamic update typically follows the workflow:

1. Local update of the underlying combinatorial structure (e.g., augmenting or pruning a decomposition tree or support hypergraph).
2. Identification (using local search or automata) of regions where protrusions can be merged or replaced while preserving problem equivalence.
3. Execution of predefined kernelization operations, such as performing a "Merge" or making local algebraic reductions.

Key features guaranteeing fast update include bounded degree of critical nodes, well-linkedness invariants, and balancing operations that maintain shallow decomposition tree depths.

3. Kernelization Results and Supported Problem Classes

Dynamic kernelization frameworks capture a wide spectrum of parameterized problems under structural restrictions and dynamic operations:

Problem Type	Graph Class	Kernel Size (as function of $OPT$ or $k$)	Update Time
Dominating Set (Planar)	Planar graphs	$O(\mathrm{OPT})$	$O(\log n)$
Feedback Vertex Set, $r$-Dom Set	Minor/topological-minor-free	$O(\mathrm{OPT})$ (with FII and treewidth)	$O(\log n)$
Vertex Cover, Cluster Vertex Deletion	General (by approximation)	$O(k^2)$, $O(k^5)$	$\mathrm{poly}(k)\log n$
Temporal $k$-Exploration (struct param)	Temporal, structured	Polynomial in $p$ ($p =$ edge repetitions)	Polynomial in $p$
Matching, Hitting Set (stream model)	General, $d$-uniform graphs	$\tilde{O}(k^2)$, $\tilde{O}(k^d)$	$\tilde{O}(1)$

Key problem classes covered include:

• All CMSO-definable problems on topological-minor-free (and minor-free) graphs which are linearly treewidth-bounding and have finite integer index (FII). Examples: Dominating Set, $r$-Dominating Set, Feedback Vertex Set, Connected Vertex Cover, $F$-Minor-Packing (Bertram et al., 5 Nov 2025).
• Classical NP-hard problems admitting constant-factor approximations and associated parameterized kernels in dynamic (fully streaming or FPT) models, e.g., Minimum Hitting Set, $b$-Matching, $k$-Colorable Subgraph, etc. (Chitnis et al., 2015, Iwata et al., 2014, Alman et al., 2017).

4. Dynamic Data Structures and Core Algorithmic Objects

Dynamic kernelization relies on specialized, efficiently maintainable data structures catering to dynamic combinatorial decompositions:

• Superbranch Decompositions and Downwards Well-Linkedness: Maintain root degree and adhesion bounded by $O(\mathrm{tw}(G))$, with non-root bag degrees $O(1)$, and overall depth $O(\log n)$. Four local rotation primitives (edge-contraction, node-split, leaf-insert/delete) support $O(1)$ or $O(\log n)$ update (Bertram et al., 5 Nov 2025).
• Dynamic Protrusion Decomposition: Every update potentially triggers a bounded cascade of merges to maintain the protrusion invariants—$O(1)$ changes to the reduced kernel per update.
• Automata for Protrusion Replacement: Tree-decomposition automata encode homomorphism types, FII equivalence, and CMSO-membership, supporting $O(1)$ amortized time per decomposition node in propagating state changes and representative shifts (Bertram et al., 5 Nov 2025, Garnero et al., 2013).
• Local Search and "Chip" Maintenance: Internally connected pieces of bounded size/boundary are indexed for rapid queries, enabling detection of "mergeable" sets (Bertram et al., 5 Nov 2025).
• Algebraic Compression: In settings with weighted components (e.g., temporal graphs), Frank–Tardos weight reduction is employed as a final step to generate small, integer-valued kernels of polylogarithmic bit length (Arrighi et al., 2023).

Maintenance of these structures ensures invariant-preserving, worst-case update times that respect kernel size bounds and problem equivalence classes.

5. Impact on Fixed-Parameter Tractability and Dynamic Approximation

Dynamic kernelization enables efficient dynamic FPT and approximation algorithms:

• Dynamic FPT: Many graph problems with $2^{O(\sqrt{k})} n^{O(1)}$ static algorithms yield $2^{O(\sqrt{k})} + O(\log n)$ update/query algorithms when paired with dynamic linear kernels (Bertram et al., 5 Nov 2025). For example, Feedback Vertex Set on undirected graphs is maintained under edge updates with $2^{O(k \log k)} \log^{O(1)} n$ amortized update times and $O(k)$ query time (Alman et al., 2017).
• Constant-Factor Approximations: The fact that $|K| = O(\mathrm{OPT}(G))$ ensures that continuous kernel maintenance provides $O(1)$-approximate solutions at every step, with modest amortized update costs.
• Bridging to Treewidth and Dynamic Decomposition: Dynamic kernelization structures serve as black-box reductions for maintaining bounded-treewidth decompositions, recovering and extending known results on dynamic treewidth computation for sparse graphs (Bertram et al., 5 Nov 2025).

Dynamic kernelization thus bridges the gap between static preprocessing (where kernelization was originally developed) and dynamic, real-time decision-making in large-scale, evolving combinatorial systems.

6. Barriers, Lower Bounds, and Limitations

Research delineates both possibilities and limits of dynamic kernelization:

• Problem Restrictions: The dynamic meta-kernelization framework crucially demands the problem admit (i) linear treewidth bounding (e.g., through bidimensionality), and (ii) finite integer index (typically arising in MSO/CMSO-expressible and bounded-expansion settings) (Bertram et al., 5 Nov 2025, Garnero et al., 2013). Problems lacking such structural properties generally preclude dynamic kernels with strong guarantees.
• Directed Variants: Directed Feedback Vertex Set and Directed $k$-Path provably lack dynamic $n^{o(1)}$ update/query time algorithms (even for $k \leq 3$) under standard complexity hypotheses (RO and LRO) (Alman et al., 2017).
• Lower Bounds for Streaming and Sampling Models: For parameterized problems such as $d$-Hitting Set, lower bounds of $\Omega(k^d)$ space or update cost apply for dynamic streaming algorithms, matching the upper bounds modulo log factors (Chitnis et al., 2015). For $\alpha$-approximate matching, space lower bounds are $\Omega(n^2/\alpha^3)$ (Chitnis et al., 2015).
• Promise Model Gaps: Many dynamic algorithms assume a promise (e.g., solution size remains bounded throughout, or graph class remains closed under edits); relaxing these can increase update times or even preclude dynamic kernelization.

These barriers clarify the domain of applicability and pinpoint open research directions, notably the extension to more general classes (such as problems beyond the reach of Courcelle-type logic/meta-kernel theorems).

7. Emerging Directions and General Design Lessons

Dynamic kernelization algorithms reshape the landscape of parameterized preprocessing under evolving input, with several thematic take-aways:

• Decomposition-based locality: Maintenance of localized decompositions (protrusions, superbranches, treewidth modulators) enables focused updates and low-overhead solution tracking even as the large-scale structure changes rapidly.
• Finite-index and encoding machinery: The systematic exploitation of equivalence classes and automata (finite integer index, CMSO-definability) yields both explicit dynamic routines and bounds on kernel sizes.
• Streaming and sublinear models: Dynamic sampling primitives work hand-in-hand with kernelization, supporting efficient streaming, distributed, and parallel kernel extraction.
• Bridging static and dynamic paradigms: The techniques simultaneously generalize and strengthen classical meta-kernelization theorems, placing dynamic kernelization as a core component of modern algorithmic toolkits for both static and real-time environments.

Multiple open questions remain, particularly in extending dynamic kernelization to broader classes of problems, closing tightness gaps in update time lower bounds, and abstraction beyond the promise model. The field is positioned at the intersection of structural combinatorics, parameterized complexity, and online algorithmics, with wide-ranging implications for real-time data analysis, large-scale graph mining, and dynamic optimization.