Face Cover Number in Planar Graphs

• The Face Cover Number problem is defined for a planar graph with a set of terminal vertices, asking if an embedding exists where all terminals lie on at most k face boundaries.
• Its complexity diverges based on the graph’s embedding, with fixed embeddings reducible to Red–Blue Dominating Set, while non-embedded cases require advanced dynamic programming.
• Recent advances achieve a cubic kernelization for non-embedded graphs using SPR-tree decomposition and reduction gadgets, setting the stage for future improvements in embedding-sensitive problems.

The Face Cover Number problem is a fundamental question at the intersection of planar graph theory, parameterized algorithms, and combinatorial topology. Given a planar graph $G$, a designated subset of vertices $T \subseteq V(G)$ termed terminals, and an integer parameter $k$, the problem asks: Does there exist a planar embedding of $G$ such that all terminals lie on the boundaries of at most $k$ faces? In its algorithmic form, this is a decision problem parameterized by $k$, with a natural minimization variant seeking the smallest $k$ for which such an embedding and face cover exist. The Face Cover Number problem exhibits distinct algorithmic and combinatorial complexity depending on whether the graph’s embedding is fixed (embedded/plane) or must be selected (non-embedded/planar) (Hamm et al., 7 Jan 2026).

1. Formal Problem Definition and Variants

Let $G = (V, E)$ be a simple planar graph and $T \subseteq V$ a distinguished set of terminals. For any planar (combinatorial) embedding $\phi$ of $G$, the embedding induces a partition of the plane into faces. A face $f$ covers a terminal $t \in T$ if $t$ lies on the boundary of $f$. A set of faces $\mathcal{F}$ is a face-cover of $(G, T)$ if every $t \in T$ is covered by at least one face in $\mathcal{F}$.

The face-cover number is defined as: $\fc(G, T) = \min_{\phi} |\mathcal{F}|$ where the minimum is over all possible planar embeddings $\phi$ of $G$, and all collections $\mathcal{F}$ of faces in $\phi$ covering $T$.

Decision problem (Face Cover Number):

• Input: Planar graph $G$, terminal set $T \subseteq V(G)$, integer $k$.
• Parameter: $k$.
• Question: Is $\fc(G, T) \leq k$? I.e., does there exist an embedding of $G$ and a collection of at most $k$ faces whose boundaries cover all terminals?

This problem admits three combinatorial variants depending on constraints on the use of external faces in graph decompositions; these are relevant in the dynamic programming approach but the main combinatorial invariant is always $\fc(G, T)$.

2. Complexity Landscape and Prior Work

The complexity of the Face Cover Number problem diverges sharply depending on whether the input is an embedded (plane) graph or a planar graph without a fixed embedding.

Embedded (Plane) Case

When the input is a plane graph with a fixed embedding, the problem reduces to the Red–Blue Dominating Set on the graph dual. In this formulation, each face becomes a dual vertex, each terminal a blue vertex, and the task is to dominate all blue vertices by faces. This reduction enables powerful kernelization results:

• A linear kernel of size $O(k)$ exists for the Red–Blue Dominating Set on planar graphs [Garnero, Sau, Thilikos 2017].
• Earlier work established quadratic kernels or subexponential FPT algorithms for specific terminal families [Kloks et al. 2002; Fernau & Juedes 2004; Koutsonas & Thilikos 2011].

Non-Embedded (Planar) Case

Here, the lack of a predetermined embedding means the face structure is not fixed and must be chosen to optimize face covering—introducing substantial algorithmic complexity. Until 2026, no polynomial kernel was established for the Face Cover Number in planar, non-embedded graphs (Hamm et al., 7 Jan 2026).

3. Polynomial Kernelization via SPR-Tree Decomposition

The main result of (Hamm et al., 7 Jan 2026) is the construction of a cubic kernel for the non-embedded Face Cover problem: a polynomial-time algorithm reduces any instance $(G, T, k)$ to an equivalent instance $(G', T', k')$ with $|V(G')| + k' = O(k^3)$ and $k' \leq k$, preserving the answer.

The kernelization utilizes bottom-up dynamic programming on an SPR-tree (also known as an SPQR-tree) decomposition of the input planar graph. The decomposition, performed in linear time [Hopcroft & Tarjan 1973], organizes the 2-connected structure of $G$ into node types:

• S-node: Skeleton is a simple cycle.
• P-node: Skeleton is a “dipole” (two vertices with parallel edges).
• R-node: Skeleton is a 3-connected planar graph.

Each SPR-tree node $t$ corresponds to a subgraph $G_t$, with virtual edges linking to child components (“virtual components”), whose types—terminal-free, unproblematic, semi-problematic, and problematic—dictate reduction strategies. “Nice kernels” are introduced as surrogate subgraphs that preserve face-cover properties across all variants of external face interaction, under all possible modifications to the corner vertices.

Key reduction gadgets are applied at each node:

• Terminal-free and unproblematic virtual components are replaced by minimal gadgets (e.g., a single edge or a $P_3$).
• Semi-problematic components employ a fixed 6-vertex gadget.
• Problematic components invoke recursive kernelization.

Child type and face-counting arguments (via a “3-connected face-sharing bound”: in a 3-connected planar graph no three distinct vertices lie on the boundary of two distinct faces) allow for bounding the count of problematic and semi-problematic children in the decomposition. At each step, new kernels of size $O(k^3)$ are constructed and propagated upward.

4. Algorithmic Outline and Reduction Rules

The kernelization proceeds through several algorithmic phases:

1. Preprocessing: Removal of degree-0 vertices; tackling disconnected components; reducing the graph to 2-connected blocks; initial FPT checks.
2. SPR-Tree Construction: In $O(|V|)$ time, the SPR-tree organizes the structure for dynamic programming.
3. Bottom-Up Processing: Each node is handled based on its type, with local reduction rules:
   • S-node rules: Contract terminal-free components, manage multi-edges, and bound the number of surviving unproblematic/semi-problematic children.
   • P-node rules: Remove all but one real edge/component; bound the number of child components by observing face consumption.
   • R-node rules: Limit the number of problematic and semi-problematic children via pigeonhole and face-counting; perform heavy-face pruning, boring edge removals/contractions, and rigidization to maintain 3-connectivity and unique embedding.
4. Finalization at Root: The root node yields a $O(k^3)$-vertex kernel instance equivalent to the original.

Local exchange arguments and detailed structural lemmas ensure the safeness of each reduction, particularly that the kernel preserves the face-cover number up to the cutoff $k$ as required.

5. Structural Lemmas and Combinatorial Invariants

• Exchange Lemma: Replacement gadgets precisely preserve cover numbers $\fc_i$ for $i=0,1,2$ (number of used external faces), maintaining equivalence except when both original and replacement exceed $k$.
• Face Sharing Bound: In a 3-connected planar graph with $n \geq 4$ vertices, no three distinct vertices appear on more than one common face—pivotal for the counting arguments bounding problematic subcomponents and for deletion rules targeting "terminal-heavy" faces.

These structural facts underpin the entire kernelization strategy, especially the ability to localize combinatorial modifications without altering the global answer.

6. Comparisons and Open Problems

The obtained cubic kernel for the non-embedded case stands in contrast to the linear kernel for the embedded (plane) case, where the dual reduction to Red–Blue Dominating Set directly applies (Hamm et al., 7 Jan 2026). The necessity of embedding selection in the non-embedded setting inherently complicates reduction techniques, although polynomial bounds are still achievable through structural decompositions.

Several open problems remain:

• Linear or Quadratic Kernel: Can the $O(k^3)$ bound be improved? A gap exists between the cubic kernel and the $O(k)$ bound for embedded graphs, raising the question of whether better bounds are possible, potentially through deeper understanding of global embedding properties under face-cover constraints.
• Subexponential FPT Algorithm: The problem does not conform to bidimensionality frameworks when $T \neq V(G)$, complicating the search for $2^{O(\sqrt{k})} \cdot n^{O(1)}$-time algorithms. Development of such algorithms for the non-embedded face cover would represent a significant advance.

7. Significance and Broader Impact

The introduction of a polynomial kernel for Face Cover Number on non-embedded planar graphs resolves a key question in planar graph kernelization. The methodology developed—a synthesis of advanced graph decomposition, kernelization gadgetry, and delicate face-counting—demonstrates that the increased flexibility (and complexity) of non-fixed embeddings does not preclude strong kernelization results. This insight not only closes a long-standing open question but also establishes foundational techniques for future work on parameterized planar graph problems requiring embedding choice (Hamm et al., 7 Jan 2026).

A plausible implication is that these reduction frameworks may extend to further embedding-sensitive covering and separation problems on planar and minor-closed graph families, provided similar combinatorial invariants can be identified and leveraged.