SAT Backdoors: Depth Beats Size

For several decades, much effort has been put into identifying classes of CNF formulas whose satisfiability can be decided in polynomial time. Classic results are the linear-time tractability of Horn formulas (Aspvall, Plass, and Tarjan, 1979) and Krom (i.e., 2CNF) formulas (Dowling and Gallier, 1984). Backdoors, introduced by Williams Gomes and Selman (2003), gradually extend such a tractable class to all formulas of bounded distance to the class. Backdoor size provides a natural but rather crude distance measure between a formula and a tractable class. Backdoor depth, introduced by M\"{a}hlmann, Siebertz, and Vigny (2021), is a more refined distance measure, which admits the utilization of different backdoor variables in parallel. Bounded backdoor size implies bounded backdoor depth, but there are formulas of constant backdoor depth and arbitrarily large backdoor size. We propose FPT approximation algorithms to compute backdoor depth into the classes Horn and Krom. This leads to a linear-time algorithm for deciding the satisfiability of formulas of bounded backdoor depth into these classes. We base our FPT approximation algorithm on a sophisticated notion of obstructions, extending M\"{a}hlmann et al.'s obstruction trees in various ways, including the addition of separator obstructions. We develop the algorithm through a new game-theoretic framework that simplifies the reasoning about backdoors. Finally, we show that bounded backdoor depth captures tractable classes of CNF formulas not captured by any known method.


Introduction
Deciding the satisfiability of a propositional formula in conjunctive normal form (CnfSat) is one of the most important NP-complete problems [4,16].Despite its theoretical intractability, heuristic algorithms work surprisingly fast on real-world CnfSat instances [7].A common explanation for this discrepancy between theoretical hardness and practical feasibility is the presence of a certain "hidden structure" in realistic CnfSat instances [14].There are various approaches to capturing the vague notion of a "hidden structure" with a mathematical concept.One widely studied approach is to consider the hidden structure in terms of decomposability.For instance, CnfSat can be solved in quadratic time for classes of CNF formulas of bounded branchwidth [2] or bounded treewidth [24].

46:2 SAT Backdoors: Depth Beats Size
A complementary approach proposed by Williams et al. [26] considers the hidden structure of a CnfSat instance in terms of a small number of key variables, called backdoor variables, that when instantiated move the instance into a polynomial-time solvable class.More precisely, a backdoor1 of size k of a CNF formula F into a polynomial-time solvable class C is a set B of k variables such that for all partial assignments τ to B, the instantiated formula F [τ ] belongs to C. In fact, CnfSat can be solved in linear time for any class of CNF formulas that admit backdoors of bounded size into the class of Horn, dual Horn or Krom (i.e., 2CNF) formulas 2 .
The size of a smallest backdoor of a CNF formula F into a class C is a fundamental but rather simple distance measure between F and C. Mählmann, Siebertz, and Vigny [17] proposed to consider instead the smallest depth over all backdoors of a formula F into a class C as distance measure.It is recursively defined as follows: Conn(F ) denotes the set of connected components of F ; precise definitions are given in Section 2. We can certify depth C (F ) ≤ k with a component C-backdoor tree of depth ≤ k which is a decision tree that reflects the choices made in the above recursive definition.
Backdoor depth is based on the observation that if an instance F decomposes into multiple connected components of F [x = 0] and F [x = 1], then each component can be treated independently.This way, one is allowed to use in total an unbounded number of backdoor variables.However, as long as the depth of the component C-backdoor tree is bounded, one can still utilize the backdoor variables to solve the instance efficiently.In the context of graphs, similar ideas are used in the study of tree-depth [19,20] and elimination distance [3,6].Bounded backdoor size implies bounded backdoor depth, but there are classes of formulas of unbounded backdoor size but bounded backdoor depth.
The challenging algorithmic problem C-Backdoor Depth is to find for a fixed base class C and a given formula F , a component C-backdoor tree of F of depth ≤ k.Mählmann et al. [17] gave an FPT-approximation algorithm for this problem, with k as the parameter) where C is the trivial class Null for formulas without variables.A component Null-backdoor tree must instantiate all variables of F .New Results.In this paper, we give the first positive algorithmic results for backdoor depth into nontrivial classes.A minimization problem admits a standard fixed-parameter tractable approximation (FPT-approximation) [18] if for an instance of size n and parameter k there is an FPT-algorithm, i.e., an algorithm running in time f (k)n O (1) , that either outputs a solution of size at most g(k) or outputs that the instance has no solution of size at most k, for some computable functions f and g; g(k) is also referred to as the performance ratio of the algorithm.
▶ Main Result 1 (Theorem 15).C-Backdoor Depth admits an FPT-approximation algorithm if C is any of the Schaefer classes Horn, dual Horn, or Krom.
Since our FPT algorithms have linear running time for fixed backdoor depth k, we obtain the following corollary: ▶ Main Result 2 (Corollary 16).CnfSat can be solved in linear time for formulas of bounded backdoor depth into the Schaefer classes Horn, dual Horn, and Krom.
Backdoor depth is a powerful parameter that is able to capture and exploit structure in CnfSat instances that is not captured by any other known method.We list some well-known parameters which render CnfSat fixed-parameter tractable (the list is not complete but covers some of the most essential parameters).For all these parameters, there exist CNF formulas with constant backdoor depth (into Horn, dual Horn, and Krom) but where the other parameter is arbitrarily large: (i) backdoor size into Horn, dual Horn, and Krom [21]; (ii) number of leaves of backdoor trees into Horn, dual Horn, and Krom [23,22]; (iii) backdoor depth into the class of variable-free formulas [17]; (iv) backdoor treewidth to Horn, dual Horn, and Krom [9,8]; (v) backdoor size into heterogeneous base classes based on Horn, dual Horn, and Krom [11]; (vi) backdoor size into scattered base classes based on Horn, dual Horn, and Krom [10]; (vii) deletion backdoor size into the class of quadratic Horn formulas [12]; (viii) backdoor size into bounded incidence treewidth [13].We give definitions and separation proofs in the full version.

Approach and Techniques.
A common approach to construct backdoors is to compute in parallel both an upper bound and a lower bound.The upper bounds are obtained by constructing the backdoor itself, and lower bounds are usually obtained in the form of so-called obstructions.These are parts of an instance that are proven to be "far away" from the base class.Our results and techniques build upon the pioneering work by Mählmann et al. [17], who introduce obstruction trees for backdoor depth.A main drawback of their approach is that it is limited to the trivial base class Null, where the obstructions are rather simple because they can contain only boundedly many variables.Our central technical contribution is overcoming this limitation by introducing separator obstructions.
Separator obstructions allow us to algorithmically work with obstruction trees containing an unbounded number of variables, an apparent requirement for dealing with nontrivial base classes different form Null. In the context of backdoor depth, it is crucial that an existing obstruction is disjoint from all potential future obstructions, so they can later be joined safely into a new obstruction of increased depth.Mählmann et al. [17] ensure this by placing the whole current obstruction tree into the backdoor -an approach that only works for the most trivial base class because only there the obstructions have a bounded number of variables.As one considers more and more general base classes, one needs to construct more and more complex obstructions to prove lower bounds.For example, as instances of the base class no longer have bounded diameter (of the incidence graph of the formula) or bounded clause length, neither have the obstructions one needs to consider.Such obstructions become increasingly hard to separate.Our separator obstructions can separate obstruction trees containing an unbounded number of variables from all potential future obstruction trees.We obtain backdoors of bounded depth by combining the strengths of separator obstructions and obstruction trees.We further introduce a game-theoretic framework to reason about backdoors of bounded depth.With this notion, we can compute winning strategies instead of explicitly constructing backdoors, greatly simplifying the presentation of our algorithms.
We provide the proofs of statements marked with ⋆ in the full version.Let τ : X → {0, 1} be an assignment of some set X of propositional variables.If X = {x} and τ (x) = ϵ, we will sometimes also denote the assignment τ by x = ϵ for brevity.We denote by true(τ ) (false(τ )) the set of all literals satisfied (falsified) by τ , i.e., true . We denote by F [τ ] the formula obtained from F after removing all clauses that are satisfied by τ and from the remaining clauses removing all literals that are falsified by τ , i.e., We say that an assignment satisfies F if F [τ ] = ∅.We say that F is satisfiable if there is some assignment τ : var(F ) → {0, 1} that satisfies F , otherwise F is unsatisfiable.CnfSat denotes the propositional satisfiability problem, which takes as instance a CNF formula, and asks whether the formula is satisfiable.
The incidence graph of a CNF formula F is the bipartite graph G F whose vertices are the variables and clauses of F , and where a variable x and a clause c are adjacent if and only if x ∈ var(c).We identify a subgraph G ′ of the incidence graph G F with the formula F ′ consisting of all the clauses of F that are in G ′ , each restricted to the adjacent variables in G ′ .With slight abuse of notation, we define var(F ′ ) to be the variables occuring in G ′ .Via incidence graphs, graph theoretic concepts directly translate to CNF formulas.For instance, we say that F is connected if G F is connected, and F ′ is a connected component of F if F ′ is a maximal connected subset of F .Conn(F ) denotes the set of connected components of F .We will also consider the primal graph of a CNF formula F , which has as vertex set var(F ), and has pairs of variables x, y ∈ var(F ) adjacent if and only of x, y ∈ var(c) for some c ∈ F .
Base classes.Let α ⊆ {+, −} with α ̸ = ∅, let F ∈ CNF and c ∈ F .We say that a literal l is an α-literal if is a positive literal and + ∈ α or it is a negative literal and − ∈ α.We say that a variable v α-occurs in in a clause c, if v or ¬v is an α-literal that is contained in c.We denote by var α (c) the set of variables that α-occur in c.For α ⊆ {+, −} with α ̸ = ∅ and s ∈ N, let C α,s be the class of all CNF formulas F such that every clause of F contains at most s α-literals.For C ⊆ CNF, we say that a clause c is C-good if {c} ∈ C. Otherwise, c is C-bad.Let τ be any (partial) assignment of the variables of F .We will frequently make use of the fact that C α,s is closed under assignments, i.e., if The classes C α,s capture (according to Schaefer's Dichotomy Theorem [25]) the largest syntactic classes of CNF formulas for which the satisfiability problem can be solved in polynomial time: The class C {+},1 = Horn of Horn formulas, the class of C {−},1 = dHorn of dual Horn formulas, and the class C {+,−},2 = Krom of Krom (or 2CNF ) formulas.Note also that the class Null of formulas containing no variables considered by Mählmann et al. [17] is equal to C {+,−},0 .We follow Williams et al. [26] and focus on classes that are closed under assignments and therefore we do not consider the classes of 0/1-valid and affine formulas.
Note that every class C α,s (and therefore also the classes of Krom, Horn, and dual Horn formulas) is trivially linear-time recognizable, i.e., membership in the class can be tested in linear-time.We say that a class C of formulas is tractable or linear-time tractable, if CnfSat restricted to formulas in C can be solved in polynomial-time or linear-time, respectively.The classes Horn, dHorn, Krom are linear-time tractable [1,5].

Backdoor Depth
A binary decision tree is a rooted binary tree T .Every inner node t of T is assigned a propositional variable, denoted by var(t), and has exactly one left and one right child, which corresponds to setting the variable to 0 or 1, respectively.Moreover, every variable occurs at most once on any root-to-leaf path of T .We denote by var(T ) the set of all variables assigned to any node of T .Finally, we associate with each node t of T , the truth assignment τ t that is defined on all the variables var(P ) \ {var(t)} occurring on the unique path P from the root of T to t such that τ t (v) = 0 (τ t (v) = 1) if v ∈ var(P ) \ {var(t)} and P contains the left child (right child) of the node t ′ on P with var(t ′ ) = v.Let C be a base class, F be a CNF formula, and T be a decision tree with var(T ) ⊆ var(F ).Then T is a C-backdoor tree of F if F [τ t ] ∈ C for every leaf t of T [23].
Component backdoor trees generalize backdoor trees as considered by Samer and Szeider [23] by allowing an additional node type, component nodes, where the current instance is split into connected components.More precisely, let C be a base class and F a CNF formula.A component C-backdoor tree for F is a pair (T, φ), where T is a rooted tree and φ is a mapping that assigns each node t a CNF formula φ(t) such that the following conditions are satisfied: 1.For the root r of T , we have φ(r) = F .

3.
For each non-leaf t of T , there are two possibilities: a. t has exactly two children t 0 and t 1 , where for some variable x ∈ var(φ(t)) we have Thus, a backdoor tree is just a component backdoor tree without component nodes.The depth of a C-backdoor is the largest number of variable nodes on any root-to-leaf path.The C-backdoor depth depth C (F ) of a formula F into a base class C is the smallest depth over all component C-backdoor trees of F .Alternatively, we can define C-backdoor depth recursively as in equation ( 1) from the introduction.For a component backdoor tree (T, φ) let var(T, φ) be the set of all variables x such that some variable node t of T branches on x.We observe that one can use component C-backdoor trees to decide the satisfiability of a formula.
▶ Lemma 1 (⋆).Let C ⊆ CNF be tractable, let F ∈ CNF, and let (T, φ) be a component C-backdoor tree of F of depth d.Then, we can decide the satisfiability of F in time 1) .Moreover, if C is linear-time tractable, then the same can be done in time

Technical Overview
We present all our algorithms in this work within a game-theoretic framework.This framework builds upon the following equivalent formulation of backdoor depth using splitter games.Similar games can be used to describe treedepth and other graph classes [15].
▶ Definition 2. Let C ⊆ CNF and F ∈ CNF.We denote by Game(F, C) the so-called C-backdoor depth game on F .The game is played between two players, the connector and the splitter.The positions of the game are CNF formulas.At first, the connector chooses a connected component of F to be the starting position of the game.The game is over once a position in the base class C is reached.We call these positions the winning positions (of the splitter).In each round the game progresses from a current position J to a next position as follows: he splitter chooses a variable v ∈ var(J).
The connector chooses an assignment τ : {v} → {0, 1} and a connected component The next position is J ′ .In the (unusual) case that a position J contains no variables anymore but J is still not in C, the splitter looses.For a position J, we denote by τ J the assignment of all variables assigned up to position J.
The following observation follows easily from the definition of the game and the fact that the (strategy) tree obtained by playing all possible plays of the connector against a given d-round winning strategy for the splitter forms a component backdoor tree of depth d, and vice versa.In particular, the splitter choosing a variable v at position J corresponds to a variable node and the subsequent choice of the connector for an assignment τ of v and a component of J[τ ] corresponds to a component node (and a subsequent variable or leaf node) in a component backdoor tree.

▶ Observation 3. The splitter has a strategy for the game Game(F, C) to reach within at most d rounds a winning position if and only if F has C-backdoor depth at most d.
Using backdoor depth games, we no longer have to explicitly construct a backdoor.Instead, we present so called splitter-algorithms that play the backdoor depth game from the perspective of the splitter.The algorithms will have some auxiliary internal state that they modify with each move.Formally, a splitter-algorithm for the C-backdoor depth game to a base class C is a procedure that gets as input a (non-winning) position J of the game, together with an internal state and returns a valid move for the splitter at position J, together with an updated internal state.We will usually use the internal state to hold an obstruction that the splitter will periodically increase in size.Assume we have a game Game(F, C) and some additional input S. For a given strategy of the connector, the splitter-algorithm plays the game as one would expect: In the beginning, the internal state is initialized with S (if no additional input is given, the state is initialized empty).Whenever the splitter should make its next move, the splitter-algorithm is queried using the current position and internal state, and afterwards the internal state is updated accordingly.
▶ Definition 4. We say a splitter-algorithm implements a strategy to reach for a game Game(F, C) and input S within at most d rounds a position and internal state with some property if and only if initializing the internal state with S and then playing Game(F, C) according to the splitter-algorithm leads -no matter what strategy the connector is usingafter at most d rounds to a position and internal state with said property.
The following observation converts splitter-algorithms into algorithms for bounded depth backdoors.It builds component backdoor trees by trying all moves of the connector.
▶ Lemma 5 (⋆).Let C ⊆ CNF and f C : N → N. Assume there exists a splitter-algorithm that implements a strategy to reach in each play in the game Game(F, C) and non-negative integer d within at most f C (d) rounds either: i) a winning position, or ii) (an internal state representing) a proof that the C-backdoor depth of F is at least d.Further assume this splitter-algorithm always takes at most O(∥F ∥) time to compute its next move.Then there is an algorithm that, given F and d, in time at most For the sake of readability, we may present splitter-algorithms as continuously running algorithms that periodically output moves (via some output channel) and always immediately as a reply get the next move of the connector (via some input channel).Such an algorithm can easily be converted into a procedure that gets as input a position and internal state and outputs a move and a modified internal state: The internal state encodes the whole state of the computation, (e.g., the current state of a Turing machine together with the contents of the tape and the position of the head).Whenever the procedure is called, it "unfreezes" this state, performs the computation until it reaches its next move and then "freezes" and returns its state together with the move.
Our main result is an approximation algorithm (Theorem 15) that either concludes that there is no backdoor of depth d, or computes a component backdoor tree of depth at most 2 2 O(d) .By Lemma 5, this is equivalent to a splitter-algorithm that plays for 2 2 O(d) rounds to either reach a winning position or a proof that the backdoor depth is larger than d.
Following the approach of Mählmann et al. [17], our proofs of high backdoor depth come in the form of so-called obstruction trees.These are trees in the incidence graph of a CNF formula.Their node set therefore consists of both variables and clauses.Obstruction trees of depth d describe parts of an instance for which the splitter needs more than d rounds to win the backdoor depth game.For depth zero, we simply take a single (bad) clause that is not allowed by the base class.Roughly speaking, an obstruction tree of depth d > 0 is built from two "separated" obstruction trees T 1 , T 2 of depth d − 1 that are connected by a path.Since the two obstruction trees are separated but in the same component, we know that for any choice of the splitter (i.e., choice of a variable v), there is a response of the connector (i.e., an assignment of v and a component) in which either T 1 or T 2 is whole.Then the splitter needs by induction still more than d − 1 additional rounds to win the game.Our splitter-algorithm will construct obstruction trees of increasing depth by a recursive procedure (Lemma 14) that we outline now.We say a splitter-algorithm satisfies property i if it reaches in each game Game(F, C) within g C (i, d) rounds (for some function g C (i, d)) either 1) a winning position, or 2) a position J and a C-obstruction tree T of depth i in F such that no variable in var(J) occurs in a clause of T , or 3) a proof that the C-backdoor depth of F is at least d.If we have a splitter algorithm satisfying property d+1 then our main result, the approximation algorithm for backdoor depth, directly follows from Lemma 7 and Lemma 5. Assume we have a strategy satisfying property i − 1, let us describe how to use it to satisfy property i.If at any point we reach a winning position, or a proof that the C-backdoor depth of F is at least d, we are done.Let us assume this does not happen, so we can focus on the much more interesting second case.
We use property i − 1 to construct a first tree T 1 of depth i − 1, and reach a position J 1 .We use it again, starting at position J 1 to construct a second tree T 2 of depth i − 1 that is completely contained in position J 1 .Since in the beginning the connector selected a connected component, T 1 and T 2 are in the same component of F and we can find a path P connecting them.Let β be the assignment that assigns all the variables the splitter chose until reaching position J 1 .Then T 2 is an obstruction tree not only in J 1 but also in F [β].In order to join both trees together into an obstruction of depth i, we have to show, according to Definition 6 that no variable v ∈ var(F [β]) occurs both in a clause of T 1 and T 2 .Since no variable in var(J 1 ) occurs in a clause of T 1 (property i − 1), and T 2 was built only from J 1 , this is the case.The trees T 1 and T 2 are "separated" and can be safely joined into a new obstruction tree T of depth i (see also Figure 3 on page 15 and the proof of Lemma 14 for details).
The last thing we need to ensure is that we reach a position J such that no variable in var(J) occurs in a clause of T .This then guarantees that T is "separated" from all future obstruction trees that we may want to join it with to satisfy property i + 1, i + 2 and so forth.This is the major difficulty and main technical contribution of this paper.
It is important to note here, that the exact notion of "separation" between obstruction trees plays a crucial role for our approach and is one of the main differences to Mählmann et al. [17].Mählmann et al. solve the separation problem in a "brute-force" manner: If we translate their approach to the language of splitter-algorithms, then the splitter simply selects all variables that occur in a clause of T .For their base class -the class Null of formulas without variables -there are at most 2 O(d) variables that occur in an obstruction tree of depth d.Thus, in only 2 O(d) rounds, the splitter can select all of them, fulfilling the separation property.This completes the proof for the base class Null.
However, already for backdoor depth to Krom, this approach cannot work since instances in the base class have obstruction trees with arbitrarily many clauses.Moreover, the situation becomes even more difficult for backdoors to Horn, since additionally clauses are allowed to contain arbitrary many literals.Mählmann et al. acknowledge this as a central problem and ask for an alternative approach to the separation problem that works for more general base classes.

Separator Obstructions
The main technical contribution of this work is a separation technique that works for the base classes C = C α,s .The separation technique is based on a novel form of obstruction, which we call separator obstruction.Obstruction trees are made up of paths, therefore, it is sufficient to separate each new path P that is added to an obstruction.Note that P can be arbitrarily long and every clause on P can have arbitrary many variables and therefore the splitter cannot simply select all variables in (clauses of) P .Instead, given such a path P that we want to separate, we will use separator obstructions to develop a splitter-algorithm (Lemma 12) that reaches in each game Game(F, C) within a bounded number of rounds either 1) a winning position, or 2) a position J such that no variable in var(J) occurs in a clause of P , or 3) a proof that the C-backdoor depth of F is at least d.
Informally, a separator obstruction is a sequence ⟨P 1 , . . ., P ℓ ⟩ of paths that form a tree T ℓ together with an assignment τ of certain important variables occurring in T ℓ .The variables of τ correspond to the variables chosen by the splitter-algorithm and the assignment τ corresponds to the assignment chosen by the connector.Each path P i adds at least one C-bad clause b i to the separator obstruction, which is an important prerequisite to increase the backdoor depth by growing the obstruction.Moreover, by choosing the important variables and the paths carefully, we ensure that for every outside variable, i.e., any variable that is not an important variable assigned by τ , there is an assignment and a component (which can be chosen by the connector) that leaves a large enough part of the separator obstruction intact.Thus, if a separator obstruction is sufficiently large, the connector can play such that even after d rounds a non-empty part of the separator obstruction is still intact.This means a large separator obstruction is a proof that the backdoor depth is larger than d.
To illustrate the growth of a separator obstruction (and motivate its definition) suppose that our splitter-algorithm is at position J of the game Game(F, C) and has already built a separator obstruction X = ⟨⟨P 1 , . . ., P i ⟩, τ ⟩ (with corresponding tree T i ) containing C-bad clauses b 1 , . . ., b i ; note that τ is compatible with τ J (i.e., τ and τ J agree on the common assigned variables).If J is already a winning position, then property i is satisfied.Therefore, J has to contain a C-bad clause.If no C-bad clause has a path to T i in J, then J satisfies 2) of property i and we are also done.Otherwise, let b i+1 be a C-bad clause in J that is closest to T i and let P i+1 be a shortest path from b i+1 to T i in J.Then, we extend our separator obstruction X by attaching the path P i+1 to T i (and obtain the tree T i+1 ).Our next order of business is to choose a bounded number of important variables occurring on P i+1 that we will add to X.Those variables need to be chosen such that no outside variable can destroy too much of the separator obstruction.Apart from destroying the paths of the separator obstruction, we also need to avoid that assigning any outside variable makes too many of the C-bad clauses b 1 , . . ., b i+1 C-good.Therefore, a natural choice would be to add all variables of b i+1 to X, i.e., to make those variables important.Unfortunately, this is not possible since b i+1 can contain arbitrarily many literals.Instead, we will only add the variables of b i+1 to X that α-occur in b i+1 .By the following lemma, the number of those variables is bounded.Next, we need to ensure that any outside variable cannot destroy too many paths.By choosing a shortest path P i+1 , we have already ensured that no variable occurs on more than two clauses of P i+1 (such a variable would be a shortcut, meaning P i+1 was not a shortest path).Moreover, because P i+1 is a shortest path from b i+1 to T i , every variable that occurs on T i and on P i+1 must occur in the clause c in P i+1 that is closest to T i but not in T i itself.Similarly, to how we dealt with the C-bad clauses, we will now add all variables that α-occur in c to X.This ensures that no outside variable can α-occur in both T i and P i+1 , which (by induction over i) implies that every outside variable α-occurs in at most two clauses (either from T i or from P i+1 ) and therefore provides us with an assignment for the outside variables that removes at most two clauses from X.However, since removing any single clause can be arbitrarily bad if the clause has a high degree in the separator obstruction, we further need to ensure that all clauses of the separator obstruction in which outside variables α-occur have small degree.We achieve this by adding the variables α-occurring in any clause as soon as its degree (in the separator obstruction) becomes larger than two, which happens whenever the endpoint of P i+1 in T i is a clause.Finally, if the endpoint of P i+1 in T i is a variable, we also add this variable to the separator obstruction to ensure that no variable has degree larger than three in T i+1 .This leads us to the following definition of separator obstructions (see also Figure 1 Moreover, let e be the variable or clause that is both in T i−1 and P i .We define B i and V i by initially setting and distinguishing two cases: If e is a variable, then let c be the clause on P i incident with e (note that it is possible that c = b i ).Then, we add c to B i and we add {e} ∪ var α (c) to V i .
If e is a clause, then either e = b i or e ̸ = b i and there is a clause c that is closest to e on P i (it may be that c = b i ).In the former case we leave B i and V i unchanged and in the latter case, we add e and c to B i and we add var α (e) ∪ var α (c) to V i .τ i : V i → {0, 1} is any assignment of the variables in V i that is compatible with τ i−1 .
We set τ = τ ℓ .The size of X is the number of paths in T = T ℓ , i.e., ℓ + 1.
The assignment τ is a central part of the definition, guiding the connector in Lemma 11 and thereby establishing a lower bound on the backdoor depth.We start by observing some simple but important properties of separator obstructions.
▶ Lemma 10 (⋆).Let F ∈ CNF, C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N, and let X = ⟨⟨P 1 , . . ., P ℓ ⟩, τ ⟩ be a C-separator obstruction in F , then for every i ∈ [ℓ]: (C1) T i is a tree.(C2) Every variable v ̸ ∈ V i occurs in at most two clauses of P j for every j with 1 ≤ j ≤ i and moreover those clauses are consecutive in P j .(C3) Every variable v ̸ ∈ V i α-occurs in at most two clauses of T i and moreover those clauses are consecutively contained in one path of

then c has degree at most two in T i . (C6) Every variable of F has degree at most three in T . (C7) If every clause of F contains at most x α-literals, then |V
We now show the main result of this subsection, namely, that also separator obstructions can be used to obtain a lower bound on the backdoor depth of CNF formulas.Proof.Let X = ⟨⟨P 1 , . . ., P ℓ ⟩, τ ⟩ be a C-separator obstruction for F of size at least ℓ with V i , B i , T i , T as in Definition 9. Let J be a position in the game Game(F, C).We say that a subtree T ′ of T = T ℓ is contained in J if every variable and clause of T ′ occurs in J. Let T ′ be a subtree of T that is contained in J. Let P j be a path of X.We say that P j is active in T ′ if either V (P j ) = {b j } and T ′ contains b j or T ′ contains a vertex in V (P j ) \ V (T j−1 ).Moreover, we say that P j is intact in T ′ at position J if V (P j ) ⊆ V (T ′ ) and b j is a C-bad clause in J. Otherwise, we say that P j is broken in T ′ at position J.
We show by induction on the number of rounds that there is a strategy S for the connector such that the following holds for every position J reached after i rounds in the game Game(F, C) against S: At position J, there is a subtree T ′ of T contained in J that contains at least ℓ i = (ℓ (1/2) i /8 i ) intact paths and at most z i = 2i broken paths of X.This then shows the statement of the lemma because ℓ d = ℓ 1/2 d /8 d = 14 2 + 2d ≥ 1 and therefore any position J reached after d rounds in the game Game(F, C) contains at least one clause that is C-bad in J.
The claim clearly holds for i = 0 since ℓ 0 = ℓ and z 0 = 0 and the connector can choose the component of F containing T .Assume now that i > 0 and let J be the position reached after i − 1 rounds.By the induction hypothesis, at position J there is a subtree T ′ of T contained in J containing at least ℓ i−1 = ℓ (1/2) i−1 /8 i−1 intact paths and at most z i−1 = 2(i − 1) broken paths of X. Suppose that the splitter chooses variable v as its next move.Moreover, let o be the smallest integer such that 46:12 SAT Backdoors: Depth Beats Size i < o.Let I be the set of all paths P j of X that are intact in T ′ at position J and let I <o (I >o ) be the subset of I containing only the paths P j with j < o (j > o).Finally, let T ′ <o be the subtree of T ′ restricted to the paths P j of X with j < o.Note that at position J, T ′ <o is connected and the paths in I <o are intact also in T ′ <o .Then, the connector chooses the assignment β : {v} → {0, 1} such that: As we will show below, β is defined in such a manner that the position J ′ = J[β] reached after the next round of the game Game(F, C) contains a subtree T ′′ of T ′ containing at least ℓ i = ℓ i−1 /8 paths that are intact in J ′ and at most z i = z i−1 + 2 broken paths, which completes the proof since the connector can now chose the component of J ′ containing T ′′ to fulfill the induction invariant.We distinguish the following cases; refer also to Figure 2 for an illustration of the two cases.
Case 1: |I <o | ≥ ℓ i−1 .We will show that T ′′ can be obtained as a subtree of T ′ <o .Note first that all clauses b j with j < o that are C-bad in J are also C-bad in J ′ .This is because v / ∈ V j (because j < o and v / ∈ V o−1 ) and therefore v cannot α-occur in b j , which implies that b j remains C-bad and not satisfied after setting v to β(v).
The tree T ′ <o in J may decompose into multiple components in J ′ .We will argue that one of these components contains many intact paths and only at most two more broken paths than T ′ <o .Since the C-bad clauses of an intact path remain C-bad in J ′ , the only way in which an intact path can become broken is if parts of the path get removed, i.e., either v or clauses satisfied by setting v to β(v).
If β(v) = 1 then + ∈ α.If β(v) = 0 then + ̸ ∈ α, and since α ̸ = ∅, then − ∈ α.Thus, in J ′ = J[β], the only elements that are removed are the variable v as well as clauses in which v α-occurs.By Lemma 10 (C3), v α-occurs in at most two clauses of T ′ <o and because of (C5) those clauses have degree at most two in T ′ <o .Therefore, setting v to β(v) removes at most two clauses from T ′ <o , each of which having degree at most two.Moreover, according to Lemma 10 (C6), v itself has degree at most three in T ′ <o .This implies that setting v to β(v) splits T ′ <o into at most 2 • 2 + 3 = 7 components.Moreover, because of Lemma 10 (C3), the at most two clauses of T ′ <o in which v αoccurs are located on the same path P j .Therefore, at most two paths that are complete in T ′ <o , i.e., the path P j and the at most one path containing v, can become broken.Therefore, there is a component of J ′ that contains a subtree of T ′ <o that contains at least In this case, we will build the subtree T ′′ by picking only one path from T ′ <o and the remaining paths from P o+1 , . . ., P ℓ .Let A be the set of all paths of X that are active in T ′ and let A >o (A <o ) be the subset of A containing only the paths P j with j > o (j < o).We say that a path P a of X is attached to a path P b of X if a > b, V (P a ) ∩ V (P b ) ̸ = ∅ and there is no b ′ < b with V (P a ) ∩ V (P b ′ ) ̸ = ∅.We say that a path P a in A >o is weakly attached to a path P b in A <o if either: P a is attached to P b or P a is attached to a path P c in A >o that is in turn weakly attached to P b .

46:13
Left: Case 1.The set I<o is large.Assigning v to β(v) decomposes the tree T ′ <o into at most seven components.The largest component T ′′ is still large.Right: Case 2. The set I<o is small.There is a path P to which many paths are weakly attached, forming a tree TP .Assigning v to β(v) splits TP in at most three parts.The largest component T ′′ of TP is still large.
Note that because T ′ is a tree, every path in A >o is weakly attached to exactly one path in A <o .Moreover, for the same reason any path in A <o together with all paths in A >o that are weakly attached to it forms a subtree of T ′ .
Therefore, there is a path P in A <o such that at least |I >o |/|A <o | paths in I >o are weakly attached to P .Moreover, the union T P of P and all paths in A >o that are weakly attached to P is a subtree of T ′ .Note that T P has at least |I >o |/|A <o | paths that are intact in T P and at most z i−1 paths that are broken in T P at position J. Since ℓ i−1 ≥ ℓ d = 14 2 + 2d ≥ 2d and Because β(v) = τ (v), all paths P j with j > o that are active in T P are still contained in J ′ and moreover if P j is intact in J, then it is still intact in J ′ .Moreover, because of Lemma 10 (C2), v occurs in at most two clauses of P and because β(v) = τ (v) all paths P o+1 , • • • , P ℓ that are attached to P are still attached to P after setting v to β(v).It follows that setting v to β(v) removes at most two clauses and at most one variable (i.e., the variable v) from P and also from T P .Therefore, J ′ = J[β] contains a component that contains a subtree T ′′ of T P with at least 3ℓ i /3 = ℓ i paths that are intact in T ′′ and at most z i−1 + 1 ≤ z i paths that are broken in T ′′ .◀

Winning Strategies and Algorithms
We are ready to present our algorithmic results.Earlier, we discussed that separator obstructions are used to separate existing obstruction trees from future obstruction trees.As all obstruction trees are built only from shortest paths, it is sufficient to derive a splitteralgorithm that takes a shortest path P and separates it from all future obstructions.By reaching a position J such that no variable in var(J) occurs in a clause of P , we are guaranteed that all future obstructions are separated from P , as future obstructions will only contain clauses and variables from J.

E S A 2 0 2 2
▶ Lemma 12 (⋆).Let C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N.There exists a splitter-algorithm that implements a strategy to reach for each game Game(F, C), nonnegative integer d, and shortest path P between two C-bad clauses in F within at most (3s + d + 1)(8 d (14 2 + 2d)) 2 d rounds either: 1) a winning position, or 2) a position J such that no variable in var(J) occurs in a clause of P , or 3) a proof that the C-backdoor depth of F is at least d.This algorithm takes at most O(∥F ∥) time per move.
Since selecting more variables can only help the splitter in archiving their goal, we immediately also get the following statement from Lemma 12.
▶ Corollary 13.Consider C = C α,s with ⊆ {+, −}, α ̸ = ∅, and s ∈ N, a game Game(F, C) and a position J ′ in this game, a non-negative integer d and shortest path P between two C-bad clauses in F .There exists a splitter-algorithm that implements a strategy that continues the game from position J ′ and reaches within at most (3s + d + 1)(8 d (14 2 + 2d)) 2 d rounds either: 1) a winning position, or 2) a position J such that no variable in var(J) occurs in a clause of P , or 3) a proof that the C-backdoor depth of F is at least d.This algorithm takes at most O(∥F ∥) time per move.
As described at the end of Section 4, we can now construct in the following lemma obstruction trees of growing size, using the previous corollary to separate them from potential future obstruction trees.
▶ Lemma 14.Let C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N.There is a splitter-algorithm that implements a strategy to reach for a game Game(F, C) and non-negative integers i, d with 1 ≤ i ≤ d within at most (2 i − 1)(3s + d + 1)(8 d (14 2 + 2d)) 2 d rounds either: 1) a winning position, or 2) a position J and a C-obstruction tree T of depth i in F such that no variable in var (J) occurs in a clause of T , or 3) a proof that the C-backdoor depth of F is at least d.This algorithm takes at most O(∥F ∥) time per move.
Proof.We will prove this lemma by induction over i.Our splitter-algorithm will try construct an obstruction tree of depth i by first using the induction hypothesis to build two obstruction trees T 1 and T 2 of depth i − 1 and then joining them together.After the construction of the first tree T 1 , we reach a position J 1 and by our induction hypothesis no variable in var(J 1 ) occurs in a clause of T 1 .This encapsulates the core idea behind our approach, as it means that T 1 is separated from all potential future obstruction trees T 2 that we build from position J 1 .Therefore, we can compute the next tree T 2 in J 1 and join T 1 and T 2 together in accordance with Definition 6 by a path P .At last, we use Corollary 13 to also separate this path from all future obstructions.If at any point of this process we reach a winning position or a proof that the C-backdoor depth of F is at least d, we can stop.Let us now describe this approach in detail.
For convenience, let x = (3s + d + 1)(8 d (14 2 + 2d)) 2 d .We start our induction with i = 1.If there is no C-bad clause in F , then it is a winning position and we can stop.Assume there is exactly one C-bad clause c in F .By Lemma 8, if c contains more then d + s α-literals, we have a proof that the C-backdoor depth of F is at least d and we archive case 3) of the lemma.On the other hand, if c contains at most d + s α-literals, the splitter can obtain a Overview of the construction in Lemma 14.First, T1 is chosen in F , yielding J1.Then, T2 is chosen in J1, yielding J2.In the end the connecting path P is chosen yielding J.A gray doublesided arrow between a position J and structure T symbolizes that no variable v ∈ var( J) occurs in a clause of T .
winning position in Game(F, C) after at most d + s ≤ (2 i − 1)x rounds by choosing a new variable α-occurring in c at every round.Assume there is more than one C-bad clause in F .Thus, we pick C-bad clauses c 1 and c 2 and compute a shortest path P between c 1 and c 2 in F .By Definition 6, T = {c 1 } ∪ {c 2 } ∪ var(P ) ∪ P is a C-obstruction tree of depth 1 in F .We then continue the game using Corollary 13 (for the path P ) to reach a position J ′ satisfying (1), (2), or (3) after at most x ≤ (2 i − 1)x rounds, with each round taking at most O(∥F ∥) time.
We now assume the statement of this lemma to hold for i − 1 and we show it also holds for i.To this end, we start playing the game Game(F, C) according to the existing splitter-algorithm for i − 1.If we reach (within at most (2 i−1 − 1)x rounds) a winning position or a proof that the C-backdoor depth of F is at least d then we are done.Assuming this is not the case, we reach a position J 1 and a C-obstruction tree T 1 of depth i − 1 in F such that no variable v ∈ var(J 1 ) occurs in a clause of T 1 .
We continue playing the game at position J 1 according to the existing splitter-algorithm for Game(J 1 , C) and i − 1.The C-backdoor depth of F is larger or equal to the C-backdoor depth of J 1 .Thus again (after at most (2 i−1 − 1)x rounds) we either are done (because we reach a winning position or can conclude that the C-backdoor depth of J 1 is at least d) or we reach a position J 2 and a C-obstruction tree T 2 of depth i − 1 in J 1 such that no variable v ∈ var(J 2 ) occurs in a clause of T 2 .
We pick two clauses c 1 ∈ T 1 and c 2 ∈ T 2 that are C-bad in F and compute a shortest path P between c 1 and c 2 in F .We now argue that T = T 1 ∪T 2 ∪var(P )∪P is a C-obstruction tree of depth i in F .Let β = τ J1 be the assignment that assigns all the variables the splitter chose until reaching position J 1 to the value given by the connector.Note that J 1 is a connected component of F [β].
Since all variables and clauses belonging to T 2 induce a connected subgraph of J 1 , T 2 is a C-obstruction tree of depth i − 1 not only in J 1 , but also in F [β].Let v ∈ var(F [β]).We show that v does not occur both in some clause of T 1 and of T 2 .To this end, assume v is contained in a clause of T 2 .Since all clauses of T 2 are in J 1 and J 1 is a connected component of F [β], we further have v ∈ var(J 1 ).On the other hand (as discussed earlier), no variable v ∈ var(J 1 ) is contained in a clause of T 1 .By Definition 6, T = T 1 ∪ T 2 ∪ var(P ) ∪ P is a C-obstruction tree of depth i in F .
We use Corollary 13 to continue playing the game at position J 2 .Again, if we reach a winning position or a proof that the C-backdoor depth of F is at least d we are done.So we focus on the third case that we reach (within at most x rounds) a position J such that E S A 2 0 2 2 no variable v ∈ var(J) is contained in a clause of P .We know already that no variable v ∈ var(J 1 ) is contained in a clause of T 1 and no variable v ∈ var(J 2 ) is contained in a clause of T 2 .Since var(J) ⊆ var(J 2 ) ⊆ var(J 1 ), and T = T 1 ∪ T 2 ∪ var(P ) ∪ P , we can conclude that no variable v ∈ var(J) is contained in a clause of T .
In total, we played for (2 i−1 − 1)x + (2 i−1 − 1)x + x = (2 i − 1)x rounds.The splitteralgorithm in Corollary 13 takes at most O(∥F ∥) time per move.The same holds for the splitter-algorithm for i − 1 that we use as a subroutine.Thus, the whole algorithm takes at most O(∥F ∥) time per move.◀ The main results now follow easily by combining Lemmas 1, 5, 7, and 14. ▶

Conclusion
We show that CnfSat can be solved in linear-time for formulas of bounded C-backdoor depth whenever C is any of the well-known Schaefer classes.We achieve this by showing that C-backdoor depth can be FPT-approximated for any class C = C α,s .This allows us to extend the results of Mählmann et al. [17] for the class of variable-free formulas to all Schaefer classes.Our results provide an important milestone towards generalizing and unifying the various tractability results based on variants of C-backdoor size (see also future work below) to the only recently introduced and significantly more powerful C-backdoor depth.
Let us finish with some natural and potentially significant extensions of backdoor depth that can benefit from our approach based on separator obstructions.Two of the probably most promising ones that have already been successfully employed as extensions of backdoor size are the so-called scattered and heterogeneous backdoor sets [11,10].
Interestingly, while those two notions lead to orthogonal tractable classes in the context of backdoor size, they lead to the same tractable class for backdoor depth.Therefore, lifting these two extensions to backdoor depth, would result in a unified and significantly more general approach.While we are hopeful that our techniques can be adapted to this setting, one of the main remaining obstacles is that obstructions of depth 0 no longer are single (bad) clauses.For instance, consider the heterogeneous class C = Horn ∪ Krom.Here, a CNF formula may not be in C due to a pair of clauses, one in Horn \ Krom and another one in Krom \ Horn.Finally, an even more general but also more challenging tractable class to consider for backdoor depth is the class of Q-Horn formulas, which generalizes the heterogeneous class obtained as the union of all considered Schaefer classes.
literal is a propositional variable x or a negated variable ¬x.A clause is a finite set of literals that does not contain a complementary pair x and ¬x of literals.A propositional formula in conjunctive normal form, or CNF formula for short, is a set of clauses.We denote by CNF the class of all CNF formulas.Let F ∈ CNF and c ∈ F .We denote by var(c) the set of all variables occurring in c, i.e., var(c) = { x | x ∈ c ∨ ¬x ∈ c } and we set var(F ) = c∈F var(c).For a set of literals L, we denote by L = { ¬l | l ∈ L }, the set of complementary literals of the literals in L. The size of a CNF formula F is ∥F ∥ = c∈F |c|.
closed under partial assignments (which is the case for many natural base classes and the classes C α,s ) and (T, φ) a component C-backdoor tree of F .Then var(T, φ) is a C-backdoor of F .

▶ Definition 6 .
Let F ∈ CNF and C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N. We inductively define C-obstruction trees T for F of increasing depth.Let c be a C-bad clause of F .The set T = {c} is a C-obstruction tree in F of depth 0. Let T 1 be a C-obstruction tree of depth i in F .Let β be a partial assignment of the variables in F .Let T 2 be an obstruction tree of depth i in F [β] such that no variable v ∈ var(F [β]) occurs both in a clause of T 1 and T 2 .Let further P be (a CNF formula representing) a path that connects T 1 and T 2 in F .Then T = T 1 ∪ T 2 ∪ var(P ) ∪ P is a C-obstruction tree in F of depth i + 1. ▶ Lemma 7 (⋆).Let F ∈ CNF and C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N. If there is a C-obstruction tree of depth d in F , then the C-backdoor depth of F is larger than d.

Figure 1 A
Figure 1 A separator obstruction containing three paths P1, P2, and P3.The figure shows vertices and edges of the incidence graph.Only the colorful edges are part of separator obstruction's tree.Gray variables and clauses are mentioned under the names bi, e, and c in Definition 9.
for an illustration).▶ Definition 9. Let F ∈ CNF and C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N. A C-separator obstruction for F is a tuple X = ⟨⟨P 1 , . . ., P ℓ ⟩, τ ⟩ (where P 1 , . . ., P ℓ are paths in F and τ is an assignment of variables of F ) satisfying the following recursive definition.P 1 is a shortest path between two C-bad clauses b 0 and b 1 in
Theorem 15 (⋆).Let C = C α,s with α ⊆ {+, −}, α ̸ = ∅, and s ∈ N. We can, for a given F ∈ CNF and a non-negative integer d, in time at most 2 2 2 O(d) ∥F ∥ either 1) compute a component C-backdoor tree of F of depth at most 2 2 O(d) , or 2) conclude that the C-backdoor depth of F is larger than d.▶ Corollary 16.Let C ∈ {Horn, dHorn, Krom}.The CnfSat problem can be solved in linear time for any class of formulas of bounded C-backdoor depth.