Parameterised complexity of model checking and satisfiability in propositional dependence logic

Dependence Logic was introduced by Jouko Väänänen in 2007. We study a propositional variant of this logic (PDL) and investigate a variety of parameterisations with respect to central decision problems. The model checking problem (MC) of PDL is NP-complete (Ebbing and Lohmann, SOFSEM 2012). The subject of this research is to identify a list of parameterisations (formula-size, formula-depth, treewidth, team-size, number of variables) under which MC becomes fixed-parameter tractable. Furthermore, we show that the number of disjunctions or the arity of dependence atoms (dep-arity) as a parameter both yield a paraNP-completeness result. Then, we consider the satisfiability problem (SAT) which classically is known to be NP-complete as well (Lohmann and Vollmer, Studia Logica 2013). There we are presenting a different picture: under team-size, or dep-arity SAT is paraNP-complete whereas under all other mentioned parameters the problem is FPT. Finally, we introduce a variant of the satisfiability problem, asking for a team of a given size, and show for this problem an almost complete picture.


Introduction
The logics of dependence and independence are a recent innovation studying the notion of dependencies occurring in several areas of research: computer science, logic, statistics, game theory, linguistics, philosophy, biology, physics, and social choice theory [27]. Jouko Väänänen [47] initiated this subfield of research in 2007, and nowadays, it is a vibrant area of study [1]. Its focus widened from initially first-order dependence logic further to modal logic [48], temporal logics [33,34], probabilistic logics [15], logics for independence [32], inclusion logics [24,31], multi-team semantics [14], and poly-team semantics [29].
In this paper, we study a sub-logic of the modal variant which is called propositional dependence logic (PDL) [30,51]. The main concept also in this logic, the dependence atom dep(P ; Q), intuitively states that values of variables p ∈ P functionally determine values of variables q ∈ Q. As functional dependence only makes sense on sets of assignments, which Väänänen called teams, team semantics are the heart of the satisfaction relation |= in this logic. Formally, a team T is a set of classical propositional assignments t : VAR → { 0, 1 }, and T |= dep(P ; Q) if and only if for all t, t ∈ T , we have that t and t agree on variables in P implies t and t agree on variables in Q.
The model checking question (MC), given a team T and a PDL-formula ϕ, asks if T |= ϕ is true. The satisfiability problem (SAT), given a PDL-formula ϕ, asks for the existence of a team T such that T |= ϕ. It is known that MC as well as SAT are NPcomplete by Ebbing and Lohmann [18], respectively, by Lohmann and Vollmer [37]. These authors classify the complexity landscape of even operator-fragments of PDL yielding a deep understanding of these problems from a classical complexity point of view. For an overview of how other atoms (e.g., inclusion, or independence) influence the complexity of these problems consider the tables in the work Hella et al. [31].
Example 1 We illustrate an example from relational databases providing understanding of team logics. Table 1 depicts a database which can be expressed in PDL via binary encoding of the possible entries for the attributes. The set of rows then corresponds to a team T . The database satisfies two functional dependencies:  Notice that in propositional logic, we cannot express a table of so many values. As a result, we need to encode in binary the values of each column separately. This might cause a logarithmic blow-up (by binary encoding the universe values for each column) in the parameter values, for example, it influences the number of variables. Furthermore, one also has to rewrite variables in the occurring formulas accordingly. For instance, as in Table 1, for dep({Room, Time}; {Instructor}) this would yield the formula dep({r 1 , r 2 , t 1 , t 2 , t 3 }; {i 1 , i 2 }). The parameters discussed in this paper correspond to the already encoded values. This means that there is no need to consider the blow-up observed in the previous example.
Often, when a problem is shown to be intrinsically hard, the framework of parameterised complexity theory [13] provides a way to further unravel the true reasons for the intractability. Here, one aims for a more fine-grained complexity analysis involving the study of parameterisations and how they pin causes for intractability substantially. One distinguishes two runtimes of a different quality: f (k) · p(|x|) versus p(|x|) f (k) , where f is an arbitrary computable function, p is a polynomial, |x| the input length and k the value of the parameter. Clearly, both runtimes are polynomial in x for each fixed k but the first one is much better as the polynomial degree is independent of the parameter's value. Problems that can be solved with algorithms running in a time of the first kind are said to be fixedparameter tractable (or FPT). Whereas, problems of category two are in the complexity class XP. It is known that FPT XP [23]. Whenever runtimes of the form f (k) · p(|x|) are considered with respect to nondeterministic machines, one studies the complexity class paraNP ⊇ FPT. In between these two classes a presumably infinite W-hierarchy is contained: FPT ⊆ W[1] ⊆ W[2] ⊆ · · · ⊆ paraNP. It is unknown whether any of these inclusions is strict. Showing W[1]-hardness of a problem intuitively corresponds to being intractable in the parameterised world.
The area of research of parameterised problems is tremendously growing and often provides new insights into the inherent difficulty of the studied problems [12]. However, the area of dependence logic is rather blank with respect to this direction of research, only Meier and Reinbold [41] investigated the (parameterised) enumeration complexity of a fragment of PDL recently. As a subject of this research, we want to initiate and to further push a study of the parameterised complexity of problems in these logics.

Applications
The concept of a team in team semantics bears a close resemblance with the relations studied in relational database theory. Moreover, dependence atoms are analogous to functional dependencies in the context of database systems. The MC problem for dependence logic, for example, is analogous to determining whether a relation in the database satisfies a functional dependency.
The teams of PDL also relate to the information states of inquisitive logic [10]; a semantic framework for the study of the notion of meaning and information exchange among agents.

Contributions
We study a wealth of parameters, also relevant from the perspective of database theory. Here, the database corresponds to a team and the query that one wishes to evaluate is a PDL-formula. The parameter team-size corresponds to the number of entries in the database and #variables corresponds to the number of attributes. The parameter formula-tw denotes how much interleaving is present among the attributes in the query and dep-arity bounds the size of functional dependencies in the query. Furthermore, the parameter formula-team-tw bounds the interleaving between a query and the database, formula-size limits the size of the query, formula-depth restricts the nesting depth of the query, and #splits bounds the number of join-operations in the query. With respect to all parameters, we study MC and SAT. Furthermore, we introduce a satisfiability variant m-SAT, which has an additional unary input m ∈ N, and asks for a satisfying team of size at least m.
In Table 2, we give an overview of our results. In this article, we prove dichotomies for MC and SAT: depending on the parameter the problem is either fixed-parameter tractable or paraNP-complete. Only the satisfiability variant under the parameters formula-tw and #splits resist a complete classification and are left for further research.

Related work
The notion of treewidth is due to Robertson and Seymour [44]. The study of the complexity of bounded treewidth query evaluation is a vibrant area of research [6-9, 16, 28]. As stated earlier, the formulas of dependence logic correspond to the functional dependencies in the database context. Bläsius et al. [4] study the parameterised complexity of dependency detection. The problem is defined as, given a database T and a positive integer k whether there is a non-trivial functional dependency of size (dep-arity in our notion) at most k that is satisfied by T . These authors prove that this problem is W[2]-complete.
Prior work A preliminary version of this article appeared in the proceedings of the 11th International Symposium on Foundations of Information and Knowledge Systems [39]. The present paper provides a higher level of detail, in particular it includes full proofs for several theorems (Theorem 18,19,24,25,27) and more examples. The new material includes a new result on the problem m-SAT (Theorem 26), and also a more extended outlook in the conclusion.

Preliminaries
In this paper, we assume familiarity with standard notions in complexity theory [43] such as the classes NP and P.

Parameterised complexity
We will recapitulate some relevant notions of parameterised complexity theory, now. For a broader introduction consider the textbook of Downey and Fellows [13], or that of Flum and Grohe [23]. A parameterised problem (PP) Π ⊆ Σ * × N consists of tuples (x, k), where x is called the instance and k the (value of the) parameter.
Definition 2 (Fixed-parameter tractable and paraNP) Let Π be a PP over Σ * × N. We say that Π is fixed-parameter tractable (or is in the class FPT) if there exists a deterministic If A is a nondeterministic algorithm instead, then Π belongs to the class paraNP.
Let P be a PP over Σ * ×N. Then the -slice of P , for ≥ 0, is the set P := { x | (x, ) ∈ P }. It is customary to use the notation O (f (k)) to denote the runtime dependence only on the parameter and to ignore the polynomial factor in the input. We will use the following result from parameterised complexity theory to prove paraNP-hardness results.
Proposition 3 [23, Theorem 2.14] Let P be a PP. If there exists an ≥ 0 such that P is NP-complete, then P is paraNP-complete.
Moreover, we will use the following folklore result to get several upper bounds.

Proposition 4
Let Q be a problem such that (Q, k) is in FPT and let be another parameter such that k ≤ f ( ) for some computable function f , then (Q, ) is also in FPT.

Propositional dependence logic
Let VAR be a countably infinite set of variables. The syntax of propositional dependence logic (PDL) is defined via the following EBNF: where is verum, ⊥ is falsum, x ∈ VAR is a variable, X, Y ⊂ VAR are finite sets of variables, dep(·; ·) is called the dependence atom, and the disjunction ∨ is also called splitjunction. Observe that we only consider atomic negation. We let PL be defined as the PDLformulas without dep(·; ·). Finally, the set X in dep(X; Y ) can be empty, giving rise to formulas of the form dep(; Y ). To simplify the notation, when either set in the arguments of dep(X; Y ) is singleton then we write, for example, dep(x; y) instead of dep({x}; {y}).
Definition 5 (Team semantics) Let ϕ, ψ be PDL-formulas and P , Q ⊂ VAR be two finite sets of variables. A team T is a set of assignments t : VAR → { 0, 1 }. Furthermore, we define the satisfaction relation |= as follows, where T |= is always true, T |= ⊥ is never true, and T |= ¬dep(P ; Q) iff T = ∅: Observe that for the satisfaction of formulas of the form dep(; Q) the team has to be constant with respect to Q. That is why such atoms are called constancy atoms. Note that in literature there exist two semantics for the split-junction operator: lax and strict semantics (e.g., Hella et al. [31]). Strict semantics requires the "splitting of the team" to be a partition whereas lax semantics allow an "overlapping" of the team. We use lax semantics here. Notice that the computational complexity for SAT and MC in PDL are the same irrespective of the considered semantics. Furthermore, our proofs work for both semantics. Also note that allowing an unrestricted negation operator dramatically increases the complexity of SAT in this logic to ATIME-ALT(exp, poly) (alternating exponential time with polynomially many alternations) as shown by Hannula et al. [30]. That is one reason why we stick to atomic negation.
In the following, we define three well-known formula properties which are relevant to results in the paper. A formula φ is flat if, given any team T , we have that T |= φ ⇐⇒ { s } |= φ for every s ∈ T . A logic L is downwards closed if for every L-formula φ and team T , if T |= φ then for every P ⊆ T we have that P |= φ. A formula φ is 2-coherent if for every team T , we have that T |= φ ⇐⇒ { s i , s j } |= φ for every s i , s j ∈ T . The classical PL-formulas are flat. This also implies that for PL-formulas, the truth value is evaluated under each assignment individually, consequently, the semantics is the usual Tarski semantic. Moreover, PDL is downwards closed and every dependence atom is 2coherent.

Representation of inputs as graphs
As we will consider specific structural parameters, we need to agree on a representation of formulas, respectively, teams. Classically, propositional formulas were represented via different kinds of graphs (e.g., Gaifman graph, primal graph) [45]. However, in this setting usually CNF-formulas are considered. Coping with this restriction, Lück et al. [38] defined syntax circuits for temporal logic formulas that also allow arbitrary formulas. In our setting, we continue in this direction and define the syntax (or formula) structure with respect to a PDL-formula.
An important observation regarding the graph representation for the PDL-formulas is due to Grädel [26]. In the usual setting for logics with team semantics, we take the syntax tree and not the associated syntax structure, that is, we distinguish between different occurrences of the same subformula. The reason for this choice is that a formula φ ∨ φ is not equivalent to φ, and in its evaluation, different teams are entitled to the two occurrences of φ in the formula. Consequently, the well-formed formulas of PDL can be seen as binary trees with leaves as atomic subformulas (variables and dependence atoms).
Notice that when a PDL-formula is considered a tree, as discussed above, the parameter treewidth (Def. 9) is not meaningful anymore.
For this reason we consider the syntax structure rather than the syntax tree as a graph structure to consider treewidth as a parameter. Moreover, in the case of MC, one might include assignments in a graph representation. In the latter case, one considers the Gaifman graph of the structure that models both, the team and the input formula.
where superscripts denote the arity of each relation, then is defined as follows. The where SF(Φ) and VAR(Φ) denote the set of subformulas and variables appearing in Φ, respectively.
-SF and VAR are unary relations representing 'is a subformula of Φ' and 'is a variable in Φ' respectively. -is a binary relation such that φ A ψ iff ψ is an immediate subformula of φ and r is a constant symbol representing Φ.
-DEP is a binary relation which connects each dependence atom with the used variables. -isTrue and isFalse relate variables with the team elements. isTrue(c, x) (resp., isFalse(c, x)) is true if and only if x is mapped 1 (resp., 0) by the assignment interpreted by c.
Analogously, the syntax structure A Φ over a respective vocabulary τ Φ is defined. In this case, the team related relations are not present and the universe does not contain the m-many In the following we write A instead of A T ,Φ when it is clear that our input instance is T , Φ .

Definition 8 (Gaifman graph) Given a team T and a PDL-formula Φ, the Gaifman graph
Analogously, we let G Φ to be the Gaifman graph for the τ Φ -structure A Φ .
Note that for G Φ we have E = DEP ∪ and for G T ,Φ we have that E = DEP ∪ ∪ isTrue ∪ isfalse.
. Note that we abbreviated subformulas in the inner vertices of the Gaifman graph for presentation reasons is called bags and E T is the edge relation such that the following is true.
The width of a given tree decomposition T = (B, E T ) is the size of the largest bag minus one: max b∈B |b| − 1. The treewidth of a given graph G is the minimum over all widths of tree decompositions of G.
Observe that if G is a tree then the treewidth of G is one. Intuitively, one can say that treewidth accordingly is a measure of tree-likeness of a given graph. The decision problem to determine whether the treewidth of a given graph G = (V , E) is at most k, is NP-complete [2]. See Bodlaender's Guide [5] for an overview of algorithms that compute tree decompositions. Further note that, opposed to our parameterised setting here, where instances of PPs are pairs of strings and numbers (the latter being the value of the parameter), there exists an approach, in which one works with parameterisation functions that map the input string to the value of the parameter (e.g., Flum and Grohe [23]). Clearly, in such a setting it could be tempting to think that treewidth is not a reasonable parameter because of the mentioned hardness of computing it. However, one can circumvent this pitfall by letting the input string contain the treewidth. The parameterisation function then essentially maps to a substring of the input avoiding the need to compute it from scratch. Figure 1 represents the Gaifman graph of the syntax structure A Φ (in middle) with a tree decomposition (on the right). Since the largest bag is of size 3, the treewidth of the given decomposition is 2. Figure 2 presents the Gaifman graph of the syntax structure A T ,Φ , that is, when the team T = {s 1 , s 2 } = {0011, 1110} is also part of the input.

Example 10
In Lemma 12, we will prove that the treewidth increases when the team is also part of the input.

Considered parameterisations
We consider eight different parameters for all three problems of interest (MC, SAT and m-SAT). These include formula-tw, formula-team-tw, team-size, formula-size, #variables, formula-depth, #splits and dep-arity. All these parameters arise naturally in problems we study. Let T be a team and Φ a PDL-formula then the parameters are defined as follows: -#splits denotes the number of times a split-junction (∨) appears in Φ and #variables denotes the total number of propositional variables. formula-depth is the depth of the syntax tree of Φ, that is, the length of the longest path from root to any leaf in the tree. team-size is the size of the team T .
-The arity of a dependence atom dep(P ; Q) is the size of P and dep-arity is the maximum arity of a dependence atom in Φ.
Regarding treewidth, recall that for the MC problem, we can also include the assignmentvariable relation in the graph representation. This yields two treewidth notions formula-tw and formula-team-tw, the name emphasises whether the team is also part of the graph.
Clearly, formula-team-tw is only relevant for the MC problem.
The following lemma proves relationships between several of the aforementioned parameters. The notation κ(T , Φ) stands for the parameter value of the input instance (T , Φ). This is also visualised in Fig. 3.
Proof If a PDL-formula Φ has m variables then there are 2 m many assignments and the maximum size for a team is 2 m . As a result, we have team-size ≤ 2 #variables . Furthermore, the number of variables in a PDL-formula Φ is bounded by the formula-size and as a consequence, we have 2 #variables ≤ 2 formula-size . This proves the second claim.
If a formula Φ has formula-depth = d then there are ≤ 2 d leaves in the (binary) syntax tree of Φ and ≤ 2 d internal nodes. Then formula-size ≤ 2 2d is true. Now we prove the following non-trivial lemma stating that treewidth of the structure A T ,Φ bounds either the team size or the number of variables. This implies that bounding the treewidth of the structure also bounds either of the two parameters. Recall that for formula-team-tw, we talk about the treewidth of the Gaifman graph underlying the structure A T ,Φ that encodes the MC question.

Lemma 12 Let T , Φ be a given MC instance. Then the following relationship between parameters is true,
We prove that if formula-team-tw is smaller than the two then such a decomposition must have cycles and hence cannot be a tree decomposition. The proof uses the fact that in the Gaifman graph G T ,Φ , every team element is related to each variable. As a consequence, in any tree decomposition, the assignment-variable relations 'isTrue' and 'isFalse' cause some bag to have their size larger than either the team size or the number of variables (based on which of the two values is smaller). We consider individual bags corresponding to an edge in the Gaifman graph due to the relations from τ T ,Φ . Let { x 1 , . . . , x n } denote variables that also appear as leaves in the formula tree SF(Φ), , Φ .
Consider a minimal tree decomposition B T , ≺ for the Gaifman graph of A. Denote by B(x i , c j ) the bag that covers the edge between a variable x i and an assignment-element c j , that is, either isTrue(x i , c j ) or isFalse(x i , c j ) is true. Moreover, denote by B(x i , α) the bag covering the edge between a variable x i and its immediate -predecessor α. Recall that in the formula part of the Gaifman graph, there is a path from each variable x i to the formula Φ due to . This implies that there exists a minimal path between any pair of variables in the Gaifman graph, and this path passes through some subformula Ψ of Φ. Let B(x, α 1 ), B(α 1 , α 2 ), . . ., B(α q , Ψ ), B(Ψ, β r ), . . . , B(β 2 , β 1 ), B(β 1 , y) be the sequence of bags that covers A -edges between x and y (where q, r ≤ |SF(Φ)|). Without loss of generality, we assume that all these bags are distinct. Now, for any pair x, y of variables, the bags B(x, c i ) and B(y, c i ) contain c i for each i ≤ m and as a consequence, we have either of the following two cases. We know that if a B(x, α 1 )-B(β 1 , y)-path between x and y due to exist, then the bags B(x, c i ) and B(y, c i ) cannot be adjacent because this will produce a cycle, a contradiction again.
Moreover, for two different assignment-elements c i , c j , consider the bags B(y, c i ) and B(y, c j ). If these two bags are adjacent then B(x, c j ) and B(y, c j ) cannot be adjacent and the path between B(x, c j ) and B(y, c j ) must contain c j . Notice that both B(y, c i ), B(y, c j ) and B(x, c j ), B(y, c j ) cannot be adjacent since this would, again, create a cycle. Consequently, the two possible cases are (see Fig. 4 explaining this situation as well): first, B(y, c i ) and B(y, c j ) are not adjacent and every path between these bags contains y . Second, B(x, c j ) and B(y, c j ) are not adjacent and every path between these bags contains c j . Finally, since this is true for all variables and all elements c i with i ≤ m this proves that either there is a bag that contains all variables, or there is one that contains all c i 's. The remaining case that there are cycles in the tree decomposition is not applicable.
This proves the claim and completes the proof to the lemma.
The following corollary is immediate due to previous lemma.
Proof If formula-team-tw ≥ #variables then bounding formula-team-tw bounds #variables which in turn bounds team-size because team-size ≤ 2 #variables . Otherwise we already have formula-team-tw ≥ team-size according to Lemma 12.

Parameterised complexity of model checking in PDL
In this section, we study the model checking question under various parameterisations. Classically, the problem is NP-complete (Prop. 14). Proof The upper bounds follows from Proposition 14. For the lower bound, we prove that the 1-slice of the problem is NP-hard by reducing from 3SAT. The reduction provided by Ebbing and Lohmann (Prop. 14) uses Kripke semantics (as they aim for a modal logic related results). We slightly modify it to fit our presentation (the correctness proof is the same). Let Φ := C 1 ∧ . . . ∧ C m be an instance of 3SAT over {x 1 , . . . , x n } and each C i be a clause, that is, a set of literals (variables or negation of variables). We define an instance T , Ψ of PDL-MC such that VAR(Ψ ) = {p 1 , . . . , p n , r 1 . . . , r n }. The team T = {s 1 , . . . , s m } contains m assignments, where each assignment s i : VAR(Ψ ) → {0, 1} is defined as follows, That is, there is an assignment s i per each clause. The variable r j encodes whether or not x j appears in the clause C i , whereas, p j encodes whether x j appears positively or negatively in C i . Finally, let Ψ := "⇒". Let θ be a satisfying assignment for Φ. We construct T j for each j ≤ n such that, That is, T j contains an assignment s i if and only if the clauses C i is satisfied by θ(x j ) where i ≤ m. Clearly, T j |= r j ∧ dep(; p j ). Moreover, since every clause is satisfied, this implies that j ≤n T j = T and consequently T |= Ψ .
"⇐". Suppose that T |= Ψ , then there are T 1 , . . . , T n such that T = j ≤n T j and T j |= r j ∧dep(; p j ). Clearly p j is fixed by each T j . We construct a satisfying assignment for Φ by considering each variable in turn. For j ≤ n, let V j = {i | s i ∈ T j }. Now, s i (p j ) = 1 implies x j ∈ C i , and we set θ(x j ) = 1, otherwise set s i (p j ) = 0. This implies that ¬x j ∈ C i and we set θ(x j ) = 0. Since for every s i ∈ T there is a j ≤ n with s i ∈ T j , we have an evaluation that satisfies every clause C i ∈ Φ and, as a consequence, θ |= Φ.
Notice that the parameter formula-twis fixed in advance. This is because G Ψ is a tree; as a consequence, formula-tw = 1. This completes the proof.
Notice that the formula in the reduction from 3SAT has fixed arity for any dependence atom (that is, dep-arity = 0). As a consequence, we obtain the following corollary. The main source of difficulty in the model checking problem seems to be the splitjunction operator.
For a team of size k and a formula with only one split-junction there are 2 k many candidates for the correct split and each can be verified in polynomial time. As a result, an exponential runtime in the input length seems necessary. However, if the team size (k) is considered as a parameter then the problem can be solved in polynomial time with respect to the input size and exponentially in the parameter. We consider both parameters (team-sizeand #splits) in turn.

Theorem 17 MC parameterised by team-size is FPT.
Proof We claim that Algorithm 1 solves the task in fpt-time. The correctness follows from the fact that the procedure is simply a recursive definition of truth evaluation of PDLformulas in bottom-up fashion.
Recall that the input formula Φ is a binary tree. The procedure starts by checking whether for each atomic (or negated atomic) subformula α and each subteam P ⊆ T , P |= α. Notice that this step also takes care of negated atomic suformulas because we only allow atomic negations. Then recursively, if P |= α i for i = 1, 2 and there is a subformula α such that α = α 1 ∧ α 2 then it answers that P |= α. Moreover, if P i |= α i for i = 1, 2 and there is a subformula α such that α = α 1 ∨ α 2 then it answers that P |= α where P = P 1 ∪ P 2 .
The first loop runs in O (2 k ) steps for each leaf node and there are |Φ| many iterations, which gives a running time of |Φ| · O (2 k ), where team-size = k. At each inner node, there are at most 2 k candidates for P and Q and as a consequence, at most 2 2k pairs that need to be checked. This implies that the loop for each inner node can be implemented in O (2 2k ) steps. Furthermore, the loop runs once for each pair of subformulas α 1 , α 2 such that α 1 • α 2 is also a subformula of Φ. This gives a running time of |Φ| · O (2 2k ) for this step. Finally, in the last step a set of size k needs to be checked against a collection containing 2 k such sets, this can be done in k · O(2 k ) steps.
We conclude that the above procedure solves the MC problem in p(|Φ|) · O(2 2k ) steps for some polynomial p. The fact that we do not get a blow-up in the number of subformulas is due to the reason that the formula tree is binary. The procedure operates on a pair of subformulas in each step and the label size (|L α |) at the end of this step is again bounded by 2 k .
Regarding the parameter #splits, we show paraNP-completeness by reducing from the 3-colouring problem (3COL) and applying Proposition 3.

Theorem 18 MC parameterised by #splits is paraNP-complete.
Proof Given an instance G where G = (V , E) is a graph. We map this input to an instance (T , Φ), 2 where T is a team, and Φ is a PDL-formula with 2 split-junctions. The idea of the reduction from 3COL is to construct a team as shown in That is, we have (1) a variable x i corresponding to each node v i and (2) a variable y j,k corresponding to each edge e j and each node v k . For convenience, we will sometimes write y j instead of (y j,1 . . . y j,n ) when it is clear that we are talking about the tuple of variables corresponding to the edge e j . Consequently, we have an n-tuple of variables y j for each edge e j , where 1 ≤ j ≤ m. The idea of the team that we construct is that there is an assignment s i corresponding to each node v i that encodes the neighbourhood of v i in the graph. The assignment s i also encodes all the edges that v i participates in. This is achieved by mapping each variable y ,j in tuple y to 1 under the assignment s j if v j ∈ e whereas s j (y ,j ) = 0 if v j ∈ e and for every j = i, s j (y ,j ) = 1. Figure 5 illustrates an example to get an intuition on this construction.
Formally, we define the team as follows.
1. If G has an edge e = { v i , v j } then we set s i (x j ) = 1 and s j (x i ) = 1, and let s i (y ,1 ) = . . . = s i (y ,n ) = 1 as well as s j (y ,1 ) = . . . = s j (y ,n ) = 1 2. For the case v j ∈ e , we set s j (y ,j ) = 0 and for the remaining indices s j (y ,i ) = 1. 3. Since, we can assume w.l.o.g. the graph has no loops (self-edges) we always have Consequently, two assignments s i , s j agree on y k if the corresponding edge e k is the edge between v i and v j , and we have s i (y k ) = 1 = s j (y k ).
The choice of x i or x j to appear in the formula is irrelevant. The idea is that if there is an edge e k between two nodes v i , v j and accordingly s i (y k ) = 1 = s j (y k ) then the two assignments cannot be in the same split of the team. This is always true because in that case the assignments s i , s j cannot agree on any of x i or x j . Since, by (3.), we have s i (x i ) = 0 but there is an edge to v j and we have s j (x i ) = 1. The desired result is achieved by the following claim.
T r = T and T r |= φ. This will prove that T |= Φ because we can split T into three sub-teams such that each satisfies the disjunct.
Since for each s i , s j ∈ T r , there is no edge e = { v i , v j } this implies that for the tuple y , we have s i (y ) = s j (y ) and thereby making the dependence atom trivially true. Moreover, by 2-coherency it is enough to check only for pairs s i , s j and since the condition holds for every edge, we have T r |= φ. Since our assumption is that V can be split into three such sets, we have the split of T into three sub-teams. This gives T |= Φ.
"⇐": Conversely, assume that T can be split into three sub-teams each satisfying φ. Then we show that V 1 , V 2 , V 3 is the partition of V into three colours. Let V r = { v i | s i ∈ T r } then r≤3 V r = V and for any v i , v j ∈ V r there is no edge between v i , v j . Suppose to the contrary that there is an edge e = { v i , v j }. Then we must have s i , s j ∈ T r such that s i (y ) = 1 = s j (y ). That is, s i (y ,1 ) = 1 = s j (y ,1 ), . . . , s i (y ,n ) = 1 = s j (y ,n ). Since we have that s i (x i ) = 0 whereas s j (x i ) = 1, this implies { s i , s j } |= φ which is a contradiction.
This concludes the full proof.

Theorem 19 MC parameterised by formula-size, formula-depth or #variables is FPT.
Proof Recall the relationships between various parameters (Lemma 11). The FPTmembership for formula-size and #variables holds due to Proposition 4 and the fact the MC when parameterised by team-size is FPT. Furthermore, the FPT-membership for formula-depth follows due to the relationship between formula-size and formula-depth.
Finally, the case for formula-team-tw follows due to Corollary 13 in conjunction with the FPT result for team-size (Lemma 17).

Satisfiability
In this section, we study SAT under various parameterisations, so the question of whether there exists a team T for a given formula Φ such that T |= Φ. Notice first, that the question is equivalent to finding a singleton team. This is since PDL is downwards closed. Consequently, if there is a satisfying team, then a singleton team satisfies the formula. As a result, team semantics coincides with the usual Tarskian semantics. This facilitates, for example, determining the truth value of disjunctions in the classical way. Accordingly, simplifying the notation a bit, for SAT we now look for an assignment rather than a singleton team that satisfies the formula.

Corollary 21
The problem SAT under both parameterisations of formula-team-tw and formula-tw is the same.
The following result is obtained by classical SAT being NP-complete [11,36].

Corollary 22 SAT parameterised by team-size, or dep-arity is paraNP-complete.
Proof The 1-slice regarding team-size (a singleton team is the same as an assignment), and the 0-slice regarding dep-arity (no dependence atoms at all) is NP-hard.
Turning towards treewidth, notice that classical propositional SAT is fixed-parameter tractable when parameterised by treewidth due to Samer and Szeider [46,Thm. 1]. However, we are unable to immediately utilise their result because Samer and Szeider study CNF-formulas and we have arbitrary formulas instead. Yet, Lück et al. [38,Cor. 4.7] studying temporal logics under the parameterised approach, classified, as a byproduct, the propositional satisfiability problem with respect to arbitrary formulas to be fixed-parameter tractable.

Corollary 23 SAT parameterised by formula-tw is FPT.
Proof As before, we need to find a singleton team. This implies that split-junctions have the same semantics as classical disjunctions and dependence atoms are always satisfied. Consequently, replacing every occurrence of a dependence atom dep(P ; Q) by yields a propositional logic formula. This substitution does not increase the treewidth. Then the result follows by Lück et al. [38,Cor. 4.7]. Now, we turn towards the parameter #splits. We present a procedure that constructs a satisfying assignment s such that s |= Φ if there is one and otherwise it answers no. The idea is that this procedure needs to remember the positions where a modification in the assignment is possible. We show that the number of these positions is bounded by the parameter #splits.
Consider the syntax tree of Φ where, as before, multiple occurrences of subformulas are allowed. The procedure starts at the leaf level with satisfying assignment candidates (partial assignments, to be precise). Reaching the root it confirms whether it is possible to have a combined assignment or not. We assume that the leaves of the tree consist of literals, dependence atoms or negated dependence atoms. Accordingly, the internal nodes of the tree are only conjunction and disjunction nodes. The procedure sets all the dependence atoms to be trivially true (as we satisfy them via every singleton team). Moreover, it sets all the negated dependence atoms to be false because there can be no satisfying assignment for a negated dependence atom. Additionally, it sets each literal to its respective satisfying assignment. Ascending the tree, it checks the relative conditions for conjunction and disjunction by joining the assignments and thereby giving rise to conflicts. A conflict arises (at a conjunction node) when two assignments are joined with contradicting values for some variable. At this point, it sets this variable x to a conflict state c. At disjunction nodes the assignment stores that it has two options and keeps the assignments separately.
Joining a true-value from a dependence atom affects the assignment only at disjunction nodes. This corresponds to the intuition that a formula of the form dep(P ; Q) ∨ ψ is true under any assignment.
At a conjunction node, when an assignment s joins with a true, the procedure returns the assignment s.
Since at a split the procedure returns both assignments, for k splits there could be ≤ 2 kmany assignment choices. At the root node if at least one assignment is consistent then we have a satisfying assignment. Otherwise, if all the choices contain conflicts over some variables then there is no such satisfying singleton team. Proof We consider partial mappings of the kind t : VAR → { 0, 1, c }. Intuitively, these mappings are used to find a satisfying assignment in the process of the presented algorithm.
If t, t are two (partial) mappings then t © t is the assignment such that , if only t (x) is defined.
We prove the following claim.
Claim The formula Φ is satisfiable if and only if Algorithm 2 returns a consistent (partial) assignment s that can be extended to a satisfying assignment for Φ over VAR(Φ).

Proof of Claim
We prove using induction on the structure of Φ.
Base case Start with a variable, Φ = x. Then Φ is satisfiable and s |= Φ such that s(x) = 1. Moreover, such an assignment is returned by the procedure as depicted by line 3 of the algorithm. Similarly, the case Φ = ¬x follows by line 4. The case Φ = dep(P ; Q) or Φ = is a special case of a PDL-formula since this is true under any assignment. Line 6 in our procedure returns such an assignment that can be extended to any consistent assignment. Finally, for Φ = ⊥ or Φ = ¬dep(P ; Q), the assignment contains a conflict and can not be extended to a consistent assignment as the algorithm returns "Φ is not satisfiable". Induction Step. Notice first that if either of the two operands is then this is a special case and triggers lines 9-11 of the algorithm thereby giving the satisfying assignment. Suppose now that Φ = ψ 0 ∧ ψ 1 and that the claim is true for ψ 0 and ψ 1 . As a result, both ψ 0 and ψ 1 are satisfiable if and only if the algorithm returns a satisfying assignment for each. Let S i for i = 0, 1 be such that some consistent t i ∈ S i can be extended to a satisfying assignment t i for ψ i . Our claim is that S Φ returned by the procedure (line 13) is non-empty and contains a consistent assignment for Φ if and only if Φ is satisfiable. First note that, by induction hypothesis, S i contains all the possible partial assignments that satisfy ψ i for i = 0, 1. Consequently, S Φ contains all the possible ©joins of such assignments that can satisfy Φ. Let ψ 0 be satisfied by t 0 and ψ 1 be satisfied by t 1 . Moreover, let s ∈ S Φ be an assignment such that s = t 0 © t 1 . If s is consistent then s can be extended to a satisfying assignment s for Φ since s |= ψ i for i = 0, 1. On the other hand if every s 0 © s 1 is conflicting (for s i ∈ S i ) then there is no assignment over VAR(Φ) = VAR(ψ 1 ) ∪ VAR(ψ 2 ) that satisfies Φ. Accordingly, Φ is not satisfiable.
The case for split-junction is simpler. Suppose that Φ = ψ 0 ∨ ψ 1 and that the claim is true for ψ 1 and ψ 2 . Then Φ is satisfiable if and only if either ψ 0 or ψ 1 is satisfiable. Since the label S Φ for Φ is the union of all the labels from ψ 0 and ψ 1 , it is enough to check that either the label of ψ 0 (that is, S 0 ) or the label of ψ 1 (S 1 ) contains a consistent partial assignment. By induction hypothesis, this is equivalent to checking whether ψ 0 or ψ 1 is satisfiable. This completes the case for split-junction and the proof to our claim.
Finally, notice that the label size adds at the occurrence of a split-junction. That is, we keep all the assignment candidates separate and each such candidate is present in the label for split-junction node. In contrast, at conjunction nodes, we 'join' the assignments and for this reason, the label size is the product of the two labels. Notice that we do not get a blowup in the number of conjunction. This is because, initially the label size for each node is 1 and only at a split-junction, the size increases. This implies that the maximum size for any label is bounded by 2 #splits . As a consequence, the above algorithm runs in polynomial time in the input and exponential in the parameter. Figure 6 presents an example of using the above algorithm. To simplify the notation, we consider the assignment labels of the form {x i , ¬x j } rather than {x i → 1, x j → 0}.
The remaining cases for the parameters #variables, formula-size, or formula-depth follow easily from the previously shown results. Theorem 25 SAT parameterised by #variables, formula-size, or formula-depthis FPT.
Proof Recall that the question PDL-SAT boils down to PL-SAT of finding an assignment for a given propositional logic formula. The latter problem, when parameterised by the number of variables in the input formula, is FPT which implies that the former problem is also FPT. Note that formula-size = |Φ| and any parameterised problem Π is FPT for the parametrisation input-length. Consequently, SAT parameterised by formula-size is FPT.
If a formula Φ has formula-depth = d then there are ≤ 2 d leaves and ≤ 2 d internal nodes accordingly we have formula-size ≤ 2 2d which shows FPT membership, when parameterised by formula-depth.

A satisfiability variant
The shown results suggest that it might be interesting to study the following variant of SAT, in which we impose an additional input 1 m (unary encoding) with m ≥ 2 and ask for a satisfying team of size at least m. Let us call the problem m-SAT. Notice that since PDLformulas are downwards closed, m-SAT is equivalent to finding a team of size exactly m. We wish to emphasise that m-SAT is not the same as SAT parameterised by team-size. This is because, SAT does not ask for a team of a particular size. We also wish to mention here that the problem of finding a team of a given size (m-SAT) has not been studied before in the classical setting. A related yet different problem in the context of database is the existence of an Armstrong relation [3,19]. Given a set Γ of functional dependencies, the question is whether there exists a database D that satisfies a functional dependency dep(P ; Q) if and only if dep(P ; Q) is implied by Γ . In our setting, the problem m-SAT considers general PDL formulas (so not only functional dependencies). Moreover, m-SAT questions whether it is possible to generate a database of a particular size (m in our case), whereas the restriction that it should not satisfy any other functional dependency, is dropped. We begin by classifying the problem unparameterised, followed by proving results in parameterised setting.
The motivation for this computational task stems from the fact that, often one has a set of constraints and wishes to populate the database with a certain number of entries (m in our case). Consider a person R making a teaching-schedule at a university department. There are quite many lectures to arrange weekly and R has to follow certain constraints such as 'the teacher and the room determine the course', 'the teacher and the time determine room and the course' and many more. Obviously, R would like to have an algorithm such that the input to this algorithm is this collection of constraints as well as the solution size (the number of weekly lectures) and the algorithm makes a consistent teaching schedule for him/her.
Notice also that we require m to be given in unary. This is because, R might be looking for an arbitrary large solution. Consequently, it makes sense to ask whether we can fill the database (even with arbitrary large size) in polynomial time with respect to the input. This corresponds to the intuition that we are given an empty database with allocated memory of size m (that is, with empty rows) and we wish to populate it with the data such that it satisfies the constraints.
If we lift the restriction of m not being given in unary then the problem immediately becomes NEXP-complete. The hardness follows due to a reduction from the validity problem for PDL [49]. In polynomial time, one can count the number of proposition symbols n in a formula Φ and ask whether there is a satisfying team for Φ of size m where m = 2 n . It is easy to observe that Φ is valid if and only if Φ has a satisfying team of size m.
We prove in Theorem 26 that restricting m to be unary drops the complexity to NPcompleteness.

Theorem 26
The problem m-SAT is NP-complete when m is given in unary.
Proof Notice first that finding a team of size m is computationally harder than finding a team of size 1. Consequently, the hardness follows because SAT for PDL is NP-hard.
We prove NP-membership by presenting a non-trivial nondeterministic algorithm running in polynomial time that constructs a team of size m if it exists. Intuitively, the algorithm tries to construct a satisfying team of size m for a given formula Φ in bottom-up fashion. Starting at the level of atomic or negated atomic subformulas of Φ, the algorithm iteratively builds a team T i for i ∈ SF(Φ).
Given the input Φ, the algorithm labels each node of the tree with a satisfying team of size at most m. For each atomic/negated atomic subformula, this team is guessed nondeterministically, whereas, for each conjunction (resp., split-junction), the team is the intersection (union) of the two subteams from the successor nodes. Specifically, for each literal , the label T is a team of size at most m and T = { s i | s i ( ) = 1 }. The question of how are the other variables mapped by each s i is answered nondeterministically. For each dependence atom α = dep(X; Y ), the label T α is a team such that |T α | = min{m, 2 |X| }. If |T α | = m, the assignments over VAR(Φ) are selected nondeterministically in such a way that T α |= α. However, if |T α | = 2 |X| , then each assignment over X is selected and these assignment are extended to variables in VAR(φ)\X nondeterministically. At conjunctions, the label is the intersection of the two labels from the successor nodes and at split-junctions, the label is Algorithm 3 Algorithm for finding a satisfying team of size m.
Input : PDL-formula Φ represented by a syntax tree with atomic/negated atomic subformulas as leaves Output: A team T of size m such that T |= Φ or "Φ does not have a satisfying team of size m" 1 begin 2 foreach Leaf of the syntax tree do 3 nondeterministically guess a team T such that |T | ≤ m and T |= 4 foreach Inner node of the syntax tree in bottom-up order do 5 Let 0 , 1 be the children of with T 0 , T 1 the resp. team labels; the union. At the root level, if T Φ has size at least m then Algorithm 3 accepts, otherwise it rejects. The result follows from the downward closure property of PDL-formulas (see page 6). Moreover, the maximum label size for any node can be at most |Φ| · m because the size only increases (potentially doubles) at a split-junction. This is unproblematic since m is given in unary.
Claim Φ has a satisfying team of size m if and only if Algorithm 3 outputs such a team when given the input Φ. Moreover, Algorithm 3 runs in nondeterministic polynomial time.
Proof of Claim The result is justified by Algorithm 3 constructing the truth function for Φ in a bottom-up fashion. The idea of a truth function was introduced by Yang [51].
"⇒": Let T be a satisfying team for Φ of size m. Consider the syntax tree of Φ. Each node in the tree can be labelled with a satisfying team for this node. Moreover, the label for each node is a subteam of T , consequently, the size is bounded by m. Algorithm 3 simply selects those teams in the guessing phase that are labelled at the leaf nodes of Φ by the truth function. These teams correctly 'add-up' to T at the root node and T |= Φ due to our assumption.
"⇐": Suppose that Algorithm 3 outputs a team of size at least m. Let T 1 , . . . T n be the teams labelled by the algorithm at the leaves of Φ, where n is the number of atomic or negated atomic subformulas (leaves in the syntax tree) of Φ. First note that T i |= i where i a leaf of Φ and i ≤ n . Moreover, for each split-junction, β = α i ∨ α j the team label T β for the node β is the union T α i ∪ T α j , where T α s is the team label for α s and s ∈ {i, j }. Similarly at the conjunction nodes, the team label for the parent node is the intersection of the teams from each conjunct. Finally, at the root level, the label has size m. Now, working in the backward direction, one can obtain the truth function for T , Φ proving that T |= Φ where T is a team of size at least m.
This completes the proof to the theorem. Now, we move on to the parameterised complexity of m-SAT. Theorem 27 m-SAT parameterised by #variables, formula-size, or formula-depth is FPT, with time even linear in the input length.
Proof In the case of #variables, the maximal satisfying team has size 2 #variables . Moreover, there are a total of 2 2 #variables many teams. Consequently, we can find all satisfying teams of size m (if any) in FPT-time with respect to the parameter #variables.
For formula-size, notice first that #variables ≤ formula-size, that is, bounding formula-size also bounds #variables (Lem. 11). As a result, we have that m-SAT parameterised by formula-size is FPT.
For formula-depth notice that formula-size ≤ 2 2·formula-depth and thereby the problem is FPT under this parametrisation.
Finally, consider the brute-force (bottom-up) algorithm in each case. This algorithm evaluates each suformula against the candidate subteam for this subformula. As a consequence, this implies that the running time with respect to the input is linear in the number of subformulas. That is, the algorithm runs in time f (k)·|Φ| for a computable function f .
Neither the arity of the dependence atoms nor the team-size alone are fruitful parameters which follows from Corollary 22.
Corollary 28 m-SAT parameterised by team-size or dep-arity is paraNP-complete.

Conclusion
In this paper, we started a systematic study of the parameterised complexity of model checking and satisfiability in propositional dependence logic. For both problems, we exhibited a complexity dichotomy (see Table 2): depending on the parameter, the problem is either FPT or paraNP-complete. Interestingly, there exist parameters for which MC is easy, but SAT is hard (team-size) and vice versa (#splits).
Towards the end, we introduced a satisfiability question which also asks for a team of a given size (m-SAT). To the best of the authors' knowledge, this problem has not been studied at all in the setting of team logics. We show that in the classical setting the problem is NP-complete. The parameterised complexity of this problem currently behaves similarly to SAT though the parameters #splits and formula-tw are open for further research. Another related question would be to study the relation between the natural number m ∈ N and the properties expressible in the downwards closed team based logic. In other words, what type of PDL-formulas have a satisfying team of size m?
As future work, we want to study combinations of the studied parameters, e.g., #splits + dep-arity. This parameter is quite interesting, as dep-arity alone is always hard for all three problems, whereas #splits allows for SAT to reach FPT. It is also interesting to observe that in both of our reductions for proving hardness of MC under the parametrisation #splits and dep-arity, if dep-arity is fixed then #splits is unbounded and vice versa. The authors believe that the combination (#splits + dep-arity) may not yield FPT-membership although it might lower the complexity from paraNP-hardness.
The concept of backdoor sets [50] has turned out to be a significant parameter to study. Intuitively, it utilises the distance of a given problem instance to an efficient sub-case. When it was firstly introduced, the concept was defined with respect to CNF formulas of propositional logic. Yet, it has been transferred to different kind of logics and other areas as well: abduction [42], answer set programming [21,22], argumentation [17], default logic [20], temporal logic [40], planning [35], and constraint satisfaction [25]. For dependence logic, such a formalism does not exist so far. We discussed in Section 4, that an instance Φ of PDL-SAT can be reduced to Ψ of PL-SAT such that Φ and Ψ are equi-satisfiable. This is achieved by simply replacing every dependence atom dep(P ; Q) by . This implies that the backdoor approach of classical propositional logic for SAT also applies to propositional dependence logic. It would be interesting to study backdoors in the context of MC as well, that is, given a team T and a PDL-formula Φ, whether T |= Φ? Some approaches into the direction of a good notion of backdoor sets are promising others not. Taking the backdoor set to be a collection of variables (as in the propositional setting) is problematic, because we wish to talk about total assignments which implies that this set should contain all variables. If the backdoor set is a collection of sub-teams, then an approach via sub-solvers makes sense, but which sub-team corresponds to which sub-formula should also be specified by the backdoor set (otherwise the sub-solver has to guess it nondeterministically). Mimicking the idea of resolvents (as in the CNF-setting) is not immediate, as removing dependence atoms does not allow for removing the assignments appearing in the backdoor: e.g., for x ∧ dep(P ; Q) the literal x can be problematic.
Also, further operators such as independence and inclusion atoms will be interesting to consider. Closing, another important question for future research is to consider the parameterised version of validity and implication problem for PDL.