Parameterised Counting in Logspace

TL;DR

This paper develops a new framework for parameterised counting in logspace, introducing variants based on tail-nondeterminism and establishing natural complete problems and closure properties for these classes.

Contribution

It introduces tail-nondeterminism variants of parameterised space classes, characterises their complexity, and explores their closure properties and natural complete problems.

Findings

Defined new classes paraW[1] and paraBeta-Tail.

Identified natural complete problems for these classes.

Proved closure properties and relationships between classes.

Abstract

In this paper, we introduce a new framework for parameterised counting in logspace, inspired by the parameterised space bounded models developed by Elberfeld, Stockhusen and Tantau (IPEC 2013, Algorithmica 2015). They defined the operators paraW and paraBeta for parameterised space complexity classes by allowing bounded nondeterminism with multiple-read and read-once access, respectively. Using these operators, they characterised the parameterised complexity of natural problems on graphs. In the spirit of the operators paraW and paraBeta by Stockhusen and Tantau, we introduce variants based on tail-nondeterminism, paraW[1] and paraBeta-Tail. Then, we consider counting versions of all four operators applied to logspace and obtain several natural complete problems for the resulting classes: counting of paths in digraphs, counting first-order models for formulas, and counting graph homomorphisms. Furthermore, we show that the complexity of a parameterised variant of the determinant function for (0,1)-matrices is #paraBeta-Tail-L-hard and can be written as the difference of two functions in #paraBetaTail-L. For example, we show that the closure of #paraBetaTail-L under parameterised logspace parsimonious reductions coincides with #paraBeta-L, that is, modulo parameterised reductions, tail-nondeterminism with read-once access is the same as read-once nondeterminism. We show that all introduced classes are closed under addition and multiplication, and those without tail-nondeterminism are closed under parameterised logspace parsimonious reductions. Finally, we underline the significance of this topic by providing a promising outlook showing several open problems and options for further directions of research.

Equations

$$\{x\in \{0,1{\}}^{\ast }\mid \exists y\in \{0,1{\}}^{\ast }\text{ s.t. }M\text{ accepts }x\text{ when the choice tape is initialised with }y\}.$$

$${\phi }_k(x_1,\dots ,x_k):=(x_1=s)\wedge E(x_1,x_2)\wedge E(x_2,x_3)\wedge \cdots \wedge E(x_{k-1},x_k)\wedge x_k=t$$

$$s_h(x,k)+s_{F^{\prime }}(|\sigma (x,k)|,h(x,k))+s_{\sigma }(|x|,k)+s_{\text{bk}}(|x|,k),$$

$$f^{\prime }(h(x,k))\cdot \log |\sigma (x,k)|\le f^{\prime \prime }(k)\cdot \log |x|,$$

$$F(x,k)$$

$$=\mathrm{p}\text{-}\#\mathrm{LOG}{\mathrm{REACH}}_b((\mathfrak{G}(x,k),s(x,k),t,f(k)\cdot \log |x|),f(k)).$$

$$F(x,k)$$

$$=\mathrm{p}\text{-}\#\mathrm{REACH}((\mathfrak{G},s(x,k),t),f(k)).$$

$$\phi (x,k)=\underset{\begin{array}{c}{e}_1,e_2\in E(x,k),\\ \ell (e_1)=\ell (e_2),\\ \text{val}(e_1)\ne \text{val}(e_2)\end{array}}{\bigwedge }\neg e_1\vee \neg e_2,$$

$$(x,k)\mapsto ((\mathfrak{G}(x,k),s(x,k),t,\phi (x,k),f(k)\cdot \log |x|),f(k))$$

$${\phi }_k(x_1,\dots ,x_k):=(x_1=s)\wedge E(x_1,x_2)\wedge E(x_2,x_3)\wedge \cdots \wedge E(x_{k-1},x_k)\wedge x_k=t$$

$$\phi =\underset{i=1}{\overset{g(k)}{\bigwedge }}V(x_i)\wedge \underset{i=1}{\overset{g(k)}{\bigwedge }}\neg (V(z_i))\wedge (C_0=x_1)\wedge (C_{\mathrm{acc}}=C_{g(k)})\wedge \underset{i=1}{\overset{g(k)-1}{\bigwedge }}R(x_i,x_{i+1},z_1,\dots ,z_{g(k)}).$$

$$E^{\prime }:=$$

$$\{(x,y)\in E^{\mathbf{B}}\mid \exists 1\le i\le n:x\in C_{a_i}^{\mathbf{B}},y\in C_{a_{i+1}}^{\mathbf{B}}\}\cup$$

$$\{(x,t)\mid x\in C_{a_n}^{\mathbf{B}}\}.$$

$$p\text{mbox}-\det (A,k)=\sum _{W\in {\mathcal{W}}_{{\mathfrak{G}}_A,k}}\mathrm{sign}(W)\cdot \mathrm{weight}(W).$$

Full text

Parameterised Counting in Logspace

Anselm Haak

  

Arne Meier

  

Om Prakash

  

Raghavendra Rao B. V

In this paper, we introduce a new framework for parameterised counting in logspace, inspired by the parameterised space bounded models developed by Elberfeld, Stockhusen and Tantau (IPEC 2013, Algorithmica 2015). They defined the operators ${\mathbf{para}}_{\mathbf{W}}$ and ${\mathbf{para}}_{\beta}$ for parameterised space complexity classes by allowing bounded nondeterminism with multiple-read and read-once access, respectively. Using these operators, they characterised the parameterised complexity of natural problems on graphs. In the spirit of the operators ${\mathbf{para}}_{\mathbf{W}}$ and ${\mathbf{para}}_{\beta}$ by Stockhusen and Tantau, we introduce variants based on tail-nondeterminism, ${\mathbf{para}}_{{\mathbf{W}}[1]}$ and ${\mathbf{para}}_{\beta{\mathbf{tail}}}$. Then, we consider counting versions of all four operators applied to logspace and obtain several natural complete problems for the resulting classes: counting of paths in digraphs, counting first-order models for formulas, and counting graph homomorphisms. Furthermore, we show that the complexity of a parameterised variant of the determinant function for $(0,1)$-matrices is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-hard and can be written as the difference of two functions in $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$. These problems exhibit the richness of the introduced counting classes. Our results further indicate interesting structural characteristics of these classes. For example, we show that the closure of $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$ under parameterised logspace parsimonious reductions coincides with $\#{\mathbf{para}}_{\beta}\mathbf{L}$, that is, modulo parameterised reductions, tail-nondeterminism with read-once access is the same as read-once nondeterminism.

Initiating the study of closure properties of these parameterised logspace counting classes, we show that all introduced classes are closed under addition and multiplication, and those without tail-nondeterminism are closed under parameterised logspace parsimonious reductions.

Also, we show that the counting classes defined can naturally be characterised by parameterised variants of classes based on branching programs in analogy to the classical counting classes.

Finally, we underline the significance of this topic by providing a promising outlook showing several open problems and options for further directions of research.

1 Introduction

Parameterised complexity theory, introduced by Downey and Fellows [24], takes a two-dimensional view on the computational complexity of problems and has revolutionised the algorithmic world. Two-dimensional here refers to the fact that the complexity of a parameterised problem is analysed with respect to the input size $n$ and a parameter $k$ associated with the given input as two independent quantities. The notion of fixed-parameter tractability is the proposed notion of efficient computation. A problem with parameter $k$ is fixed-parameter tractable (fpt, or in the class $\mathbf{FPT}$) if there is a deterministic $f(k)\cdot n^{O(1)}$ time algorithm for deciding it, where $f$ is a computable function. The primary notion of intractability is captured by the $\mathbf{W}$-hierarchy in this setting.

Since its inception, the focus of parameterised complexity theory has been to identify parameterisations of $\mathbf{NP}$-hard problems that allow for efficient parameterised algorithms, and to address structural aspects of the classes in the $\mathbf{W}$-hierarchy and related complexity classes [32]. This led to the development of machine-based and logical characterisations of parameterised complexity classes (see the book by Flum and Grohe [32] for more details). While the structure of classes in hierarchies such as the $\mathbf{W}$- and $\mathbf{A}$-hierarchy is well understood, a parameterised view of parallel and space-bounded computation lacked attention.

In 2013, Elberfeld et al. [43, 27] focused on parameterised space complexity classes and initiated the study of parameterised circuit complexity classes. In fact, they introduced parameterised analogues of deterministic and nondeterministic logarithmic space-bounded classes. The machine-based characterisation of $\mathbf{W}[\mathbf{P}]$ (the class of problems that are fpt-reducible to a weighted circuit satisfiability question), and the type of access to nondeterministic choices (multi-read or read-once) led to two different variants of parameterised logspace (para-logspace), namely, ${\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and ${\mathbf{para}}_{\beta}\mathbf{L}$. Elberfeld et al. [27] obtained several natural complete problems for these classes, such as parameterised variants of reachability in graphs.

Bannach, Stockhusen and Tantau [6] further studied parameterised parallel algorithms. They used colour coding techniques [4] to obtain efficient parameterised parallel algorithms for several natural problems. A year later, Chen and Flum [15] proved parameterised lower bounds for $\mathbf{AC^{0}}$ by adapting circuit lower bound techniques.

Apart from decision problems, counting problems have found a prominent place in complexity theory. Valiant [46] introduced the notion of counting complexity classes that capture natural counting problems such as counting the number of perfect matchings in a graph, or counting the number of satisfying assignments of a CNF formula. Informally, $\#\mathbf{P}$ (resp., $\#\mathbf{L}$) consists of all functions $F\colon\{0,1\}^{*}\to\mathbb{N}$ such that there exists an nondeterministic Turing machine (NTM) running in polynomial time (resp., logarithmic space) in the input length whose number of accepting paths on every input $x\in\{0,1\}^{*}$ is equal to $F(x)$. Valiant’s theory of $\#\mathbf{P}$-completeness led to several structural insights into complexity classes around $\mathbf{NP}$ and interactive proof systems, as well as to the seminal result of Toda [45].

While counting problems in $\#\mathbf{P}$ stayed in the focus of research for long, the study of the determinant by Damm [22], Vinay [47], and Toda [44] established that the complexity of computing the determinant of an integer matrix characterises the class $\#\mathbf{L}$ up to a closure under subtraction. Allender and Ogihara [3] analysed the structure of complexity classes based on $\#\mathbf{L}$. The importance of counting classes based on logspace-bounded Turing machines (TMs) was further established by Allender, Beals and Ogihara [2]. They characterised the complexity of testing feasibility of linear equations by a class which is based on $\#\mathbf{L}$. Beigel and Fu [7] then showed that small depth circuits built with oracle access to $\#\mathbf{L}$ functions lead to a hierarchy of languages which can be seen as the logspace version of the counting hierarchy. In a remarkable result, Ogihara [40] showed that this hierarchy collapses to the first level. Further down the complexity hierarchy, Caussinus et al. [12] introduced counting versions of $\mathbf{NC^{1}}$ based on various characterisations of $\mathbf{NC^{1}}$. The counting and probabilistic analogues of $\mathbf{NC^{1}}$ exhibit properties similar to their logspace counterparts [23]. Moreover, counting and gap variants of the class $\mathbf{AC^{0}}$ were defined by Agrawal et al. [1].

The theory of parameterised counting classes was pioneered by Flum and Grohe [31] as well as McCartin [38]. The class $\#\mathbf{W}[1]$ consists of all parameterised counting problems that reduce to the problem of counting $k$-cliques in a graph. Flum and Grohe [31] proved that counting cycles of length $k$ is complete for $\#\mathbf{W}[1]$. Curticapean [17] further showed that counting matchings with $k$ edges in a graph is also complete for $\#\mathbf{W}[1]$. These results led to several remarkable completeness results and new techniques (see, e.g., the works of Curticapean [18, 19], Curticapean, Dell and Marx [20], Jerrum and Meeks [35], Brand and Roth [10]).

Motivation

Given the rich structure of logspace-bounded counting complexity classes, the study of parameterised variants of these classes is vital to obtain a finer classification of counting problems.

A theory on para-logspace counting did not exist before. We wanted to overcome this defect to further understand the landscape of counting problems with decision versions in para-logspace-based classes. Our new framework allows us to classify many of these problems more precisely. In this article, we define counting variants inspired by the parameterised space complexity classes introduced by Elberfeld et al. [43, 27].

In the realm of space-bounded computation, different manners in which nondeterministic bits are accessed lead to different complexity classes. For example, the standard definition of $\mathbf{NL}$ implicitly gives the corresponding NTMs only read-once access to their nondeterministic bits [5]: nondeterminism is given only in the form of choices between different transitions. This means that nondeterministic bits are not re-accessible by the machine later in the computation. When instead using an auxiliary read-only tape for these bits and allowing for multiple passes on it, one obtains the class $\mathbf{NP}$. This is due to the fact that SAT is $\mathbf{NP}$-complete with respect to logspace many-one reductions [5], and that one can evaluate a CNF formula in deterministic logspace even when the assignment is given on a read-only tape. However, polynomial time bounded NTMs still characterise $\mathbf{NP}$ even when the machine is allowed to do only one pass on the nondeterministic bits as they can simply store all nondeterministic bits on the work-tape. So, it is very natural to investigate whether the differentiation from above leads to new insights in our setting.

With parameterisation as a means for a finer classification, Stockhusen and Tantau [43] defined nondeterministic logarithmic space-bounded computation based on how (unrestricted or read-once) the nondeterministic bits are accessed. Based on this distinction, they defined two operators: ${\mathbf{para}}_{\mathbf{W}}$ (unrestricted) and ${\mathbf{para}}_{\beta}$ (read-once). Their study led to many compelling natural problems that are complete for logspace-bounded nondeterministic computations with suitable parameters. Thereby, a rich structure of computational power based on the restrictions on the number of reads of the nondeterministic bits was exhibited. In this article, we additionally differentiate based on when (unrestricted or tail access) the nondeterministic bits are accessed. The classes $\mathbf{W}[1]$ and $\mathbf{W}[\mathbf{P}]$ are the two most prominent nondeterministic classes in the parameterised world which is why we wanted to see the effect of such a restriction on the rather small classes in our setting. This leads to the new operators ${\mathbf{para}}_{{\mathbf{W}}[1]}$ and ${\mathbf{para}}_{\beta{\mathbf{tail}}}$. The concept of tail-nondeterminism allowed to capture the parameterised complexity class $\mathbf{W}[1]$—via tail-nondeterministic, $k$-bounded machines—and thereby relates to many interesting problems such as searching for cliques, independent sets, or homomorphism, and evaluating conjunctive queries [32]. Intuitively, tail-nondeterminism means that all nondeterministic bits are read at the end of the computation, and $k$-boundedness limits the number of these nondeterministic bits to $f(k)\cdot\log|x|$ for all inputs $(x,k)$.

Studying counting complexity often improves the understanding of related classical problems and classes (e.g., Toda’s theorem [45]). With regard to space-bounded complexity, there are several characterisations of logspace-bounded counting classes in terms of natural problems. For example, counting paths in directed graphs is complete for $\#\mathbf{L}$, and checking if an integer matrix is singular or not is complete for the class $\mathbf{C_{=}}\mathbf{L}$ (see Allender et al. [2]). Furthermore, testing if a system of linear equations is feasible or not can be done in $\mathbf{L}$ with queries to any complete language for $\mathbf{C_{=}}\mathbf{L}$. Moreover, two hierarchies built over counting classes for logarithmic space collapse either to the first level [40] or to the second level [2]. Apart from this, the separation of various counting classes over logarithmic space remains widely open. For example, it is not known if the class $\mathbf{C_{=}}\mathbf{L}$ is closed under complementation.

We consider different parameterised variants of the logspace-bounded counting class $\#\mathbf{L}$ to give a new perspective on its fine structure.

Results

We introduce the counting variants of parameterised space-bounded computation and show that each of the parameterised logspace complexity classes, defined by Stockhusen and Tantau [43], has a natural counting counterpart. Moreover, by considering also tail-nondeterminism with respect to their classes, we obtain four different variants of parameterised logspace counting classes, namely, $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L},\#{\mathbf{para}}_{\beta}\mathbf{L},\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$, and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$. We show that $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$ are closed under para-logspace parsimonious reductions and that all of our new classes are closed under addition and multiplication.

Furthermore, we develop a complexity theory by obtaining natural complete problems for these new classes. We introduce variants of the problem of counting walks of parameter-bounded length that are complete for the classes $\#{\mathbf{para}}_{\beta}\mathbf{L}$ (Theorems 4.1, 4.3 and 4.6), $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$ (Theorem 4.4) and $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ (Theorem 4.7). Since the same problem is shown to be complete for both, $\#{\mathbf{para}}_{\beta}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$, we get the somewhat surprising result that the closure of $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$ under para-logspace parsimonious reductions coincides with $\#{\mathbf{para}}_{\beta}\mathbf{L}$ (Corollary 4.5). Also, we show that a parameterised version of the problem of counting homomorphisms from coloured path structures to arbitrary structures is complete for $\#{\mathbf{para}}_{\beta}\mathbf{L}$ with respect to para-logspace parsimonious reductions (Theorem 4.16).

Afterwards, we study variants of the problem of counting assignments to free first-order variables in a quantifier-free $\mathrm{FO}$ formula. We identify complete problems for the classes $\#{\mathbf{para}}_{\beta}\mathbf{L}$ and $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ in this context. More specifically, counting assignments to free first-order variables in a quantifier-free formula with relation symbols of bounded arity and the syntactical locality of the variables in the formula being restricted ($p\text{-}\#\mathrm{MC}(\Sigma_{0}^{r\text{-local}})_{a}$) is shown to be complete for the classes $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$ with respect to para-logspace parsimonious reductions (Theorem 4.11). When there is no restriction on the arity of relational symbols or on the locality of the variables, counting the number of satisfying assignments to free first-order variables in a quantifier-free formula in a given structure ($p\text{-}\#\mathrm{MC}(\Sigma_{0})$) is complete for $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ with respect to para-logspace parsimonious reductions (Theorem 4.13).

Finally, we consider a parameterised variant of the determinant function ($p\mbox{-}\mathrm{det}$) introduced by Chauhan and Rao [13]. By adapting the arguments of Mahajan and Vinay [37], we show that $p\mbox{-}\mathrm{det}$ on $(0,1)$-matrices can be expressed as the difference of two functions in $\#{\mathbf{para}}_{\beta}\mathbf{L}$, and is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-hard with respect to para-logspace many-one reductions (Theorem 4.20).

Figure 1 shows a class diagram with complete problems.

Main Techniques

Our primary contribution is laying foundations for the study of parameterised logspace-bounded counting complexity classes. The completeness results in Theorems 4.3 and 4.13 required a quantised normal form for $k$-bounded nondeterministic Turing Machines (NTMs) (Lemma 3.2). This normal form quantises the nondeterministic steps of a $k$-bounded NTM into chunks of $\log n$-many steps such that the total number of accepting paths remains the same. We believe that the normal form given in Lemma 3.2 will be useful in the structural study of parameterised counting classes. The study of $p\mbox{-}\mathrm{det}$ involved definitions of so-called parameterised clow sequences generalising the classical notion [37]. Besides, a careful assignment of signs to clow sequences was necessary for our complexity analysis of $p\mbox{-}\mathrm{det}$.

Related Results

Chen and Müller [14] studied the parameterised complexity of counting homomorphisms and divided the problems into four equivalence classes. However, their equivalence is only based on reductions among variants of counting homomorphisms but not in terms of concrete complexity classes. In this context, Dalmau and Johnson [21] investigated the complexity of counting homomorphisms as well, and provided generalisations of results by Grohe [33] to the counting setting. A similar classification regarding our classes can give new insights into the complexity of the homomorphism problem (Open Problem 4). The behaviour of our classes with respect to reductions is similar to the one observed for $\mathbf{W}[1]$ by Bottesch [8, 9].

Outline

In Section 2, we introduce the considered machine model, as well as needed foundations of parameterised complexity theory, and logic. Section 3 presents structural results regarding our introduced notions in the parameterised counting context. Afterwards, in Section 4, our main results on counting walks, FO-assignments, homomorphisms as well as regarding the determinant are shown. Finally, we conclude in Section 5.

Due to space limitations, all proof details can be found in the appendix.

2 Preliminaries

In this section, we describe the computational models and complexity classes that are relevant for parameterised complexity theory. We use standard notions and notations from parameterised complexity theory [24, 32]. Without loss of generality, we restrict the input alphabet to be $\{0,1\}$.

Turing Machines (TMs) with Random Access to the Input

We consider an intermediate model between TMs and Random Access Machines (RAMs) on words. Particularly, we make use of TMs that have random access to the input tape and can query relations in input structures in constant time. This can be achieved with two additional tapes of logarithmic size (in the input length), called the random access tape and the relation query tape. On the former, the machine can write the index of an input position to get the value of the respective bit of the input. On the relation query tape, the machine can write a tuple $t$ of the input structure together with a relation identifier $R$ to get the bit stating whether $t$ is in the relation specified by $R$. Note that our model achieves linear speed-up for accessing the input compared to the standard TM model. (This is further justified by Remark 2.6.) For convenience, in the following, whenever we speak about TMs we mean the TM model with random access to the input. Denote by $\mathbf{SPACETIME}(s,t)$ ($\mathbf{NSPACETIME}(s,t)$) with $s,t\colon\mathbb{N}\to\mathbb{N}$ the class of languages that are accepted by (nondeterministic) TMs with space-bound $O(s(n))$ and time-bound $O(t(n))$. A ${\mathcal{C}}$-machine for ${\mathcal{C}}=\mathbf{SPACETIME}(s,t)$ (${\mathcal{C}}=\mathbf{NSPACETIME}(s,t)$) is a (nondeterministic) TM that is $O(s(n))$ space-bounded and $O(t(n))$ time-bounded.

NTMs are a generalisation of TMs where multiple transitions from a given configuration are allowed. This can be formalised by allowing the transition to be a relation rather than a function. Sometimes, it is helpful to view NTMs as deterministic TMs with an additional tape, called the (nondeterministic) choice tape which is read-only. Let $M$ be a deterministic TM with a choice tape. A nondeterministic step in the computation of $M$ is a step where $M$ moves the head on the choice tape to a cell that was not visited before. The language accepted by $M$, $L(M)$ is defined as

[TABLE]

Notice that in this framework the machine $M$ has two-way access to the choice tape. Furthermore, resource bounds are with respect to the input only (the content of the choice tape is not part of the input) and the choice tape is not counted for space bounds. In this paper, we regard nondeterministic TMs as deterministic ones with a choice tape.

Before we proceed to the definition of parameterised complexity classes, a clarification on the choice of the model is due. Note that RAMs and NRAMs are often appropriate in the parameterised setting as exhibited by several authors (see, e.g., the textbook of Flum and Grohe [32]). They allow to define bounded nondeterminism quite naturally. On the other hand, in the classical setting, branching programs (BPs) are one of the fundamental models that represent space bounded computation, in particular logarithmic space. Since BPs inherently use bit access, this relationship suggests the use of a bit access model. Consequently, we consider a hybrid computational model: Turing machines with random access to the input. While the computational power of this model is the same as that of Turing machines and RAMs, it seems to be a natural choice to guarantee a certain robustness, allowing for desirable characterisations of our classes.

Parameterised Complexity Classes

Let $\mathbf{FPT}$ denote the set of parameterised problems that can be decided by a deterministic TM running in time $f(k)\cdot p(|x|)$ for any input $(x,k)$ where $f$ is a computable function and $p$ is a polynomial. Two central classes in parameterised complexity theory are $\mathbf{W}[1]$ and $\mathbf{W}[\mathbf{P}]$ which were originally defined via special types of circuit satisfiability [32]. Flum, Chen and Grohe [16] obtained a characterisation of these two classes using the following notion of $k$-bounded NTMs.

Definition 2.1** ($k$-bounded TMs).**

An NTM $M$, working on inputs of the form $(x,k)$ with $x\in\{0,1\}^{*},k\in\mathbb{N}$, is said to be $k$-bounded if for all inputs $(x,k)$ it reads at most $f(k)\cdot\log|x|$ bits from the choice tape on input $(x,k)$, where $f$ is a computable function.

Here, we will work with the following characterisation of $\mathbf{W}[\mathbf{P}]$. The characterisation for $\mathbf{W}[1]$ needs another concept that will be defined on the next page.

Proposition 2.2** ([16, 32]).**

$\mathbf{W}[\mathbf{P}]$* is the set of all parameterised problems that can be accepted by $k$-bounded $\mathbf{FPT}$-machines with a choice tape.*

Now, we recall three complexity theoretic operators that define parameterised complexity classes from an arbitrary classical complexity class, namely $\mathbf{para},{\mathbf{para}}_{\mathbf{W}}$ and ${\mathbf{para}}_{\beta}$, following the notation of Stockhusen [42].

Definition 2.3** ([30]).**

Let ${\mathcal{C}}$ be any complexity class. Then $\mathbf{para}{\mathcal{C}}$ is the class of all parameterised problems $P\subseteq\{0,1\}^{*}\times\mathbb{N}$ for which there is a computable function $π\colon\mathbb{N}\to\{0,1\}^{*}$ and a language $L\in{\mathcal{C}}$ with $L\subseteq\{0,1\}^{*}\times\{0,1\}^{*}$ such that for all $x\in\{0,1\}^{*}$, $k\in\mathbb{N}$: $(x,k)\in P\Leftrightarrow(x,π(k))\in L.$

Notice that $\mathbf{para}\mathbf{P}=\mathbf{FPT}$ is the standard precomputation characterisation of $\mathbf{FPT}$ [30]. A $\mathbf{para}{\mathcal{C}}$-machine for ${\mathcal{C}}=\mathbf{SPACETIME}(s,t)$ (${\mathcal{C}}=\mathbf{NSPACETIME}(s,t)$) is a (nondeterministic) TM, working on inputs of the form $(x,k)$, that is $O(s(|x|+f(k)))$ space-bounded and $O(t(|x|+f(k)))$ time-bounded where $f$ is a computable function.

The class $\mathbf{XP}$ (problems accepted in time $|x|^{f(k)}$ for a computable function $f$) and the $\mathbf{W}$-hierarchy [32] capture intractability of parameterised problems. Though the $\mathbf{W}$-hierarchy was defined using the weighted satisfiability of formulas with bounded weft, which is the number of alternations between gates of high fan-in, Flum and Grohe [30] characterised central classes in this context using bounded nondeterminism. Stockhusen and Tantau [43, 42] considered space-bounded and circuit-based parallel complexity classes with bounded nondeterminism.

The following definition is a more formal version of the one given by Stockhusen and Tantau [43, Def. 2.1]. They use $\text{para}\exists^{\leftrightarrow}_{f\log}{\mathcal{C}}$ instead of ${\mathbf{para}}_{\mathbf{W}}{\mathcal{C}}$ for a complexity class ${\mathcal{C}}$.

Definition 2.4**.**

Let ${\mathcal{C}}=\mathbf{SPACETIME}(s,t)$ for some $s,t\colon\mathbb{N}\to\mathbb{N}$. Then, ${\mathbf{para}}_{\mathbf{W}}{\mathcal{C}}$ is the class of all parameterised problems $Q$ that can be accepted by a $k$-bounded $\mathbf{para}{\mathcal{C}}$-machine with a choice tape.

For example, ${\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ denotes the parameterised version of $\mathbf{NL}$ with $k$-bounded nondeterminism. One can also restrict this model by only giving one-way access to the nondeterministic tape. The following definition is a more formal version of the one of Stockhusen and Tantau [43, Def. 2.1] who use the symbol $\text{para}\exists^{\to}_{f\log}$ instead.

Definition 2.5**.**

Let ${\mathcal{C}}=\mathbf{SPACETIME}(s,t)$ for some $s,t\colon\mathbb{N}\to\mathbb{N}$. Then ${\mathbf{para}}_{\beta}{\mathcal{C}}$ denotes the class of all parameterised problems $Q$ that can be accepted by a $k$-bounded $\mathbf{para}{\mathcal{C}}$-machine with a choice tape with one-way read access to the choice tape.

As there is only read-once access to the nondeterministic bits, ${\mathbf{para}}_{\beta}{\mathcal{C}}$ can be equivalently defined via nondeterministic transitions and without using a choice tape.

Another notion studied in parameterised complexity is tail-nondeterminism. A $k$-bounded machine $M$ is tail-nondeterministic if there exists a computable function $g$ such that on all inputs $(x,k)$, $M$ makes at most $g(k)\cdot\log n$ further steps in the computation, after its first nondeterministic step. The value of this concept is evidenced by the machine characterisation of $\mathbf{W}[1]$ (Chen et al. [16]). We hope to get new insights by transferring this concept to space-bounded computation. In consequence, we introduce the tail-nondeterministic versions of ${\mathbf{para}}_{\mathbf{W}}{\mathcal{C}}$ and ${\mathbf{para}}_{\beta}{\mathcal{C}}$ which are denoted by ${\mathbf{para}}_{{\mathbf{W}}[1]}{\mathcal{C}}$ and ${\mathbf{para}}_{\beta{\mathbf{tail}}}{\mathcal{C}}$.

Remark 2.6**.**

Note that it is important to have random access to the input tape in the case of tail-nondeterminism. Without random access to input bits and input relations, a TM cannot even make reasonable queries to the input in time $g(k)\cdot\log(n)$.

Logic

We assume basic familiarity with first-order logic (FO). A vocabulary is a finite ordered set of relation symbols and constants. Each relation symbol $R$ has an associated arity $\mathrm{arity}(R)\in\mathbb{N}$. Let $\tau$ be a vocabulary. A $\tau$-structure $\mathbf{A}$ consists of a nonempty finite set $\mathrm{dom}(\mathbf{A})$ (its universe), and an interpretation $R^{\mathbf{A}}\subseteq\mathrm{dom}(\mathbf{A})^{\mathrm{arity}(R)}$ for every relation symbol $R\in\tau$. Syntax and semantics are defined as usual (see, e.g., the textbook of Ebbinghaus et al. [26]). Let $\mathbf{A}$ be a structure with universe $A$. We denote by $|\mathbf{A}|$ the size of a binary encoding of $\mathbf{A}$, i.e., the number of bits required to represent the universe and relations as lists of tuples. For example, if $R$ is a relation of arity $3$, then $R^{\mathbf{A}}$ is represented as a subset of $A^{3}$, i.e., a set of triples over $A$. This requires $O(|R^{\mathbf{A}}|\cdot\mathrm{arity}(R))\cdot\log|A|)$ bits to represent the relation $R^{\mathbf{A}}$, assuming $\log|A|$ bits to represent an element in $A$. As analysed by Flum et al. [29, Sect. 2.3], this means that $|\mathbf{A}|\in\Theta((|A|+|\tau|+\sum_{R\in\tau}|R^{\mathbf{A}}|\cdot\mathrm{arity}(R))\cdot\log|A|)$. Also recall that the fragment $\Sigma_{i}$ (for $i\in\mathbb{N}$) refers to the class of $\mathrm{FO}$-formulas with $i$ quantifier blocks alternating between existential and universal quantifiers and the outermost quantifier being existential.

3 Parameterised Counting in Logarithmic Space

Now, we define the counting counterparts based on the parameterised classes defined using bounded nondeterminism. The definitions of the decision classes based on tail-nondeterminism can be found in the appendix. A parameterised function is a function $F\colon\{0,1\}^{*}\times\mathbb{N}\to\mathbb{N}$. For an input $(x,k)$ of $F$ with $x\in\{0,1\}^{*}$, $k\in\mathbb{N}$, we call $k$ the parameter of that input. If ${\mathcal{C}}$ is a complexity class and a parameterised function $F$ belongs to ${\mathcal{C}}$, we say that $F$ is ${\mathcal{C}}$-computable. Let $M$ be a TM. We denote by $\mathrm{acc}_{M}(x)$ the number of accepting paths of $M$ on input $x$, and similarly, $\mathrm{acc}_{M}(x,k)$, for parameterised inputs of the form $(x,k)$.

Definition 3.1**.**

Let ${\mathcal{C}}=\mathbf{SPACETIME}(s,t)$ for some $s,t\colon\mathbb{N}\to\mathbb{N}$. Then a parameterised function $F$ is in $\#{\mathbf{para}}_{\mathbf{W}}{\mathcal{C}}$ if there is a $k$-bounded nondeterministic $\mathbf{para}{\mathcal{C}}$-machine $M$ such that for all inputs $(x,k)$, we have that $\mathrm{acc}_{M}(x,k)=F(x,k)$. Furthermore, $F$ is in

• •

$\#{\mathbf{para}}_{\beta}{\mathcal{C}}$* if there is such an $M$ with read-once access to its nondeterministic bits,*

• •

$\#{\mathbf{para}}_{{\mathbf{W}}[1]}{\mathcal{C}}$* if there is such an $M$ that is tail-nondeterministic, and*

• •

$\#{\mathbf{para}}_{\beta{\mathbf{tail}}}{\mathcal{C}}$* if there is such an $M$ with read-once access to its nondeterministic bits that is tail-nondeterministic.*

By definition, we get $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}\subseteq{\mathcal{C}}\subseteq\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ for ${\mathcal{C}}\in\{\#{\mathbf{para}}_{\beta}\mathbf{L},\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}\}$. Note that the restriction of the above classes to $k$-boundedness is crucial. If we drop this restriction, the machines are able to access $2^{f(k)+log|x|}$, so fpt-many, nondeterministic bits. Regarding multiple-read access, this allows for solving SAT (with constant parameterisation). So this class then would contain a $\mathbf{para}\mathbf{NP}$-complete problem. For read-once access, we expect a similar result for $\mathbf{para}\mathbf{NL}$. When adding tail-nondeterminism, we implicitly get $k$-boundedness again, so this does not lead to new classes.

The following lemma shows that $\mathbf{para}\mathbf{L}$-machines can be normalised in a specific way. This normalisation will play a major role in Section 4.

Lemma 3.2**.**

For any $k$-bounded nondeterministic $\mathbf{para}\mathbf{L}$-machine $M$ there exists a $k$-bounded nondeterministic $\mathbf{para}\mathbf{L}$-machine $M^{\prime}$ with $\#\mathrm{acc}_{M}(x,k)=\#\mathrm{acc}_{M^{\prime}}(x,k)$ for all inputs $(x,k)$ such that $M^{\prime}$ has the following properties:

1. (1)

$M^{\prime}$* has a unique accepting configuration,* 2. (2)

on any input $(x,k)$, every computation path of $M^{\prime}$ accesses exactly $g(k)\cdot\log|x|$ nondeterministic bits (for some computable function $g$), and $M^{\prime}$ counts on an extra tape (tape $S$) the number of nondeterministic steps, and 3. (3)

$M^{\prime}$* has an extra tape (tape $C$) on which it remembers previous nondeterministic bits, resetting the tape after every $\log|x|$-many nondeterministic steps.*

Additionally, if $M$ has read-once access to its nondeterministic bits, or is tail-nondeterministic, or both, then $M^{\prime}$ also has these properties.

The following result follows from a simple simulation of nondeterministic machines by deterministic ones. Let $\mathbf{F}\mathbf{FPT}$ be the class of functions computable by $\mathbf{FPT}$-machines with output.

Theorem 3.3**.**

$\#{\mathbf{para}}_{\beta}\mathbf{L}\subseteq\mathbf{F}\mathbf{FPT}$.

Using the notion of oracle machines (see, e.g., [41]), we define Turing, metric, and parsimonious reductions computable in $\mathbf{para}\mathbf{L}$. For our purposes, the oracle tape is always exempted from space restrictions which is often the case in the context of logspace Turing reductions [11]. A study on the effect of changing this assumption might be interesting.

Definition 3.4** (Reducibilities).**

Let $F,F^{\prime}\colon\{0,1\}^{*}\times\mathbb{N}\to\mathbb{N}$ be two functions. Then, $F$ is para-logspace Turing reducible to $F^{\prime}$, $F\leq^{\mathrm{plog}}_{T}F^{\prime}$, if there is a $\mathbf{para}\mathbf{L}$ oracle TM $M$ that computes $F$ with oracle $F^{\prime}$ and the parameter of any oracle query of $M$ is bounded by a computable function in the parameter. If there is such an $M$ that uses only one oracle query, then $F$ is para-logspace metrically reducible to $F^{\prime}$, $F\leq^{\mathrm{plog}}_{\mathrm{met}}F^{\prime}$. If there is such an $M$ that returns the answer of the first oracle query, then $F$ is para-logspace parsimoniously reducible to $F^{\prime}$, $F\leq^{\mathrm{plog}}_{\mathrm{pars}}F^{\prime}$.

Note that the definition of parsimonious reductions ensures that the size of the witness set is preserved by the fact that $M$ immediately returns the answer of its only oracle query (without further computations). For any reducibility relation $\preccurlyeq$ and any complexity class ${\mathcal{C}}$, $[{\mathcal{C}}]^{\preccurlyeq}\mathrel{\mathop{:}}=\{\,A\mid\exists C\in{\mathcal{C}}\text{ such that\@\ }A\preccurlyeq C\,\}$ is the $\preccurlyeq$-closure of ${\mathcal{C}}$.

Next, we show that both new classes without tail-nondeterminism are closed under $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.

Lemma 3.5**.**

The classes $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$ are closed under $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.

For the tail-classes, such a closure property is not obvious. Corollary 4.4 will show that closing the class with read-once access and tail-nondeterminism under these reductions gives the full power of the class without tail-nondeterminism. Open Problem 2 on page 2 asks what class is obtained when closing the class without read-once access and with tail-nondeterminism.

Another important question is whether classes are closed under certain arithmetic operations. We show that all newly introduced classes are closed under addition and multiplication.

Theorem 3.6**.**

For any $o\in\{\mathbf{W},\mathbf{W}[1],\beta,\beta\mbox{-}\mathbf{tail}\}$, the class $\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$ is closed under addition and multiplication.

Open Problem 1**.**

Which of the classes are closed under monus, that is, $\max\{F-G,0\}$?

4 Complete Problems

This section studies complete problems for the previously defined classes: counting problems in the context of walks in directed graphs, model-checking problems for $\mathrm{FO}$ formulas, and homomorphisms between $\mathrm{FO}$-structures as well as a parameterised version of the determinant.

4.1 Counting Walks

We start with parameterised variants of counting walks in directed graphs which will be shown to be complete for the introduced classes.

[TABLE]

Theorem 4.1**.**

For every $b\geq 2$, $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{b}$ is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$-reductions.

Proof 4.2** (Proof Idea.).**

For the upper bound, guess a path of length exactly $a$. The number of nondeterministic bits is bounded by $O(k\cdot\log|V|)$ since successors can be referenced by a number in $\{0,\dots,b-1\}$.

For the lower bound, using Lemma 3.2, construct the configuration graph $\mathfrak{G}$ restricted to nondeterministic configurations and the unique accepting configuration $C_{\mathrm{acc}}$, where the edge relation expresses whether a configuration is reachable with exactly one nondeterministic, but an arbitrary number of deterministic steps. Accepting computations of the machine correspond to paths from the first nondeterministic configuration to $C_{\mathrm{acc}}$ of length $f(k)\cdot\log|\mathfrak{G}|$ in $\mathfrak{G}$.

Now consider the problem $\mathrm{p\text{-}}\#\mathrm{REACH}$, defined as follows.

[TABLE]

The difference to the previous problem is the unbounded out-degree of nodes and the length of counted walks being $k$ instead of $a\leq k\cdot\log|x|$. Note that the analogue problem for counting paths is $\#\mathbf{W}[1]$-complete [31]. However, we will see now that the problem for walks is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete.

Theorem 4.3**.**

$\mathrm{p\text{-}}\#\mathrm{REACH}$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

As the length of paths that are counted in $\mathrm{p\text{-}}\#\mathrm{REACH}$ is $k$, the runtime of the whole algorithm used to prove membership in the previous theorem is actually bounded by $k\cdot\log|x|$ on input $(x,k)$. This means that the computation is tail-nondeterministic.

Theorem 4.4**.**

$\mathrm{p\text{-}}\#\mathrm{REACH}$* is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

The previous results together with the fact that $\#{\mathbf{para}}_{\beta}\mathbf{L}$ is closed under $\leq^{\mathrm{plog}}_{\mathrm{pars}}$ yield the following surprising collapse (a similar behaviour was observed by Bottesch [8, 9]).

Corollary 4.5**.**

$[\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}]^{\leq^{\mathrm{plog}}_{\mathrm{pars}}}=\#{\mathbf{para}}_{\beta}\mathbf{L}$.

We continue with another variant of $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{b}$, namely $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}$. Here, all walks of length $a$ are counted, if $a\leq k\cdot\log|x|$ (and $s,t$ are not part of the input).

Theorem 4.6**.**

$\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{T}$.*

Now, consider a problem that combines a reachability problem with model-checking for propositional logic, that is, it only counts walks that are models of a propositional formula (see Haak et al. [34]). Let $\mathfrak{G}=(V,E)$ be a DAG, $(e_{1},\dots,e_{n})$ be a walk in $\mathfrak{G}$ with $e_{i}\in E$ for $1\leq i\leq n$, and $P=\{e_{1},\dots,e_{n}\}$. Define the function $c_{P}\colon E\to\{0,1\}$ to be the characteristic function of $P$ with respect to $E$: $c_{P}(e)=1$ iff $e\in P$.

[TABLE]

Theorem 4.7**.**

$\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{2}\text{-}\mathrm{CNF}$* is $\#\mathbf{para}_{W}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof 4.8** (Proof Idea.).**

Regarding membership, we can first use the algorithm outlined in the proof idea of Theorem 4.1 to nondeterministically guess a path, and then use the standard logspace model-checking algorithm for propositional formulas. Since edges in the graph are associated with variables of the formula, whenever we need the value of an edge variable $e$, we run the original algorithm re-using nondeterministic bits to determine it.

For the lower bound, we use the same graph as in Theorem 4.1, and the formula is used to express consistency of the re-used nondeterministic bits in the configuration graph.

Similarly, define the problem $\mathrm{p\text{-}}\#\mathrm{CC}_{2}\text{-}\mathrm{CNF}$: Given a graph $\mathfrak{G}=(V,E)$ of bounded out-degree 2, a CNF-formula $\varphi$ with $\mathrm{Vars}(\varphi)\subseteq E$ and $a,k\in\mathbb{N}$, with $k$ as the parameter and $a\leq\log(|G|+|\varphi|)$, output the number of cycle covers $D\subseteq E$ in which the number of non-selfloop-cycles is $\leq k$, exactly $k\cdot a$ vertices are covered non-trivially and $\mathrm{Vars}(D)\models\varphi$.

Theorem 4.9**.**

$\mathrm{p\text{-}}\#\mathrm{CC}_{2}\text{-}\mathrm{CNF}$* is $\#\mathbf{para}_{W}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

4.2 Counting FO-Assignments

Let $\mathcal{F}$ be a class of well-formed formulas. The problem of counting satisfying assignments to free $\mathrm{FO}$-variables in $\mathcal{F}$-formulas, $p\text{-}\#\mathrm{MC}(\mathcal{F})$, is defined as follows.

[TABLE]

Here, $φ(\mathbf{A})$ is the set of satisfying assignments of φ in $\mathbf{A}$: $\varphi(\mathbf{A})=\{\,(a_{1},\ldots,a_{n})\mid(a_{1},\ldots,a_{n})\in\mathrm{dom}(\mathbf{A})^{n},{\mathbf{A}}\models\varphi(a_{1},\ldots,a_{n})\,\}$. Denote by $p\text{-}\#\mathrm{MC}(\mathcal{F})_{a}$ the variant where for all relations the arity is at most $a\in\mathbb{N}$. We investigate parameterisations that yield complete problems for some of the new classes in this setting.

In particular, we consider a fragment of $\mathrm{FO}$ obtained by restricting the occurrence of variables in the syntactic tree of a formula in a purely syntactic manner. Formally, the syntax tree of a quantifier-free $\mathrm{FO}$-formula $\varphi$ is a tree with edge-ordering whose leaves are labelled by atoms of $\varphi$ and whose inner vertices are labelled by Boolean connectives.

Definition 4.10**.**

Let $r\in\mathbb{N}$ and φ be a quantifier-free $\mathrm{FO}$-formula. Let $θ_{1},\dots,θ_{m}$ be the atoms of φ in the order of their occurrence in the order-respecting depth-first run through the syntax tree of φ. We say that φ is $r$-local if for any $θ_{i}$, $θ_{j}$ that involve the same variable, we have $|i-j|\leq r$. We define \Sigma_{0}^{r\text{-local}}\mathrel{\mathop{:}}=\{\,\varphi\in\Sigma_{0}\mid\varphi\text{ is r-local}\,\}.

Using this syntactic notion, we obtain a complete problem for our classes with read-once access to nondeterministic bits in the setting of first-order model-checking.

Theorem 4.11**.**

For $a\geq 2,r\geq 1$, $\mathrm{p\text{-}}\#\mathrm{MC}(\Sigma_{0}^{r\text{-local}})_{a}$ is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.

Proof 4.12** (Proof Idea.).**

Regarding membership, we evaluate the given $\varphi$ in $\mathbf{A}$ top to bottom using the locality of $\varphi$ by storing assignments to variables until we encountered $r$ more atoms. As a result, at most $a\cdot r$ assignments to variables are simultaneously stored and each one needs $\log|\mathbf{A}|$ space. Moreover, the runtime of the whole procedure is bounded by $f(|\varphi|)\cdot\log|\mathbf{A}|$ for some computable function $f$ and thereby the procedure is tail-nondeterministic.

Regarding the lower bound, we reduce from $\mathrm{p\text{-}}\#\mathrm{REACH}$ and use the formula

[TABLE]

expressing that a tuple of vertices $(v_{1},\dots,v_{k})$ is an $s^{\mathbf{A}}$-$t^{\mathbf{A}}$-walk in an $(E,s,t)$-structure $\mathbf{A}$.

Note that the decision version of $p\text{-}\#\mathrm{MC}(\Sigma_{0})$ is equivalent to parameterised model-checking for $\Sigma_{1}$-sentences, as we count assignments to free variables. This problem characterises tail-nondeterministic para-logspace with read-once access to nondeterministic bits.

Theorem 4.13**.**

$p\text{-}\#\mathrm{MC}(\Sigma_{0})$* is $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

The complexity status of counting assignments to free first-order variables in a $\Sigma_{0}$ formula with unbounded arity or without the local restrictions is not known. In particular, it is not clear if the restriction on the arity or the locality property of the formula can be removed while preserving completeness. Finally, we close this section with three open questions.

Open Problem 2**.**

What is the complexity of $[\mathrm{p\text{-}}\#\mathrm{MC}(\Sigma_{0})_{a}]^{\leq^{\mathrm{plog}}_{\mathrm{pars}}}$ for fixed $a\in\mathbb{N}$? What is the complexity of $[\mathrm{p\text{-}}\#\mathrm{MC}(\Sigma_{0}^{r\text{-local}})]^{\leq^{\mathrm{plog}}_{\mathrm{pars}}}$ for fixed $r\in\mathbb{N}$?

Open Problem 3**.**

Is the class $[\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}]^{\leq^{\mathrm{plog}}_{\mathrm{pars}}}$ equivalent to some known class?

4.3 Counting Homomorphisms

This subsection is devoted to the study of the problem of counting homomorphisms between two structures in the parameterised setting. Typically, the size of the universe of the first structure is considered as the parameter. The complexity of counting homomorphisms has been intensively investigated for almost two decades [25, 33, 21, 14].

Definition 4.14** (Homomorphism).**

Let $\mathbf{A}$ and $\mathbf{B}$ be structures over some vocabulary $\tau$ with universes $A$ and $B$, respectively. A function $h\colon A\to B$ is a homomorphism from $\mathbf{A}$ to $\mathbf{B}$ if for all $R\in\tau$ and for all tuples $(a_{1},\dots,a_{\mathrm{arity}(R)})\in R^{\mathbf{A}}$, we have $(h(a_{1}),\dots,h(a_{\mathrm{arity}(R)}))\in R^{\mathbf{B}}$.

A bijective homomorphism $h$ between two structures $\mathbf{A},\mathbf{B}$ such that the inverse of $h$ is also a homomorphism is called an isomorphism. If there is an isomorphism between $\mathbf{A}$ and $\mathbf{B}$, then $\mathbf{A}$ is said to be isomorphic to $\mathbf{B}$.

Definition 4.15**.**

Let $\mathbf{A}$ be a structure with universe $A$. Then denote by $\mathbf{A}\!^{*}$ the extension of $\mathbf{A}$ by a fresh unary relation symbol $C_{a}$ interpreted as $C_{a}^{\mathbf{A}}=\{a\}$ for each $a\in\mathrm{dom}(\mathbf{A})$. Analogously, denote by $\mathcal{A}^{*}$ for a class of structures $\mathcal{A}$ the class $\{\,\mathbf{A}\!^{*}\mid\mathbf{A}\in\mathcal{A}\,\}$.

Define $\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{A})$ as the following problem. Given a pair of structures $(\mathbf{A},\mathbf{B})$ where $\mathbf{A}\in\mathcal{A}$, and parameter $k$, output the number of homomorphisms from $\mathbf{A}$ to $\mathbf{B}$, if $|\mathrm{dom}(\mathbf{A})|\leq k$, and 0 otherwise.

[TABLE]

Notice that $\mathbf{B}$ can be any structure. For $n\geq 2$, let $P_{n}$ be the canonical undirected path of length $n$, that is, the $(E)$-structure with universe $\{1,\dots,n\}$ and $E^{P_{n}}=\{\,(i,i+1),(i+1,i)\mid 1\leq i<n\,\}$. Let $\mathcal{P}$ be the class of structures isomorphic to some $P_{n}$. For the next theorem, reduce to $\mathrm{p\text{-}}\#\mathrm{REACH}$ for membership, and from a normalised, coloured variant of $\mathrm{p\text{-}}\#\mathrm{REACH}$ for hardness.

Theorem 4.16**.**

$\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{P}^{*})$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Open Problem 4**.**

Is there a natural class of structures $\mathcal{A}$ such that $\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{A})$ is $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$?

4.4 The Parameterised Complexity of the Determinant

In this section, we consider a parameterised variant of the determinant function introduced by Chauhan and Rao [13]. For $n>0$ let $\mathcal{S}_{n}$ denote the set of all permutations of $\{1,\ldots,n\}$. For $k\leq n$, let ${\mathcal{S}}_{n,k}$ denote the following subset of $\mathcal{S}_{n}$: ${\mathcal{S}}_{n,k}=\{\,\pi\,|\,\pi\in S_{n},|\{\,i\,:\,\pi(i)\neq i\,\}|=k\,\}.$

We define the parameterised determinant function of an $n\times n$ square matrix $A=(a_{i,j})_{1\leq i,j\leq n}$ as $p\mbox{-}\mathrm{det}(A,k)=\sum_{\pi\in S_{n,k}}\mathrm{sign}(\pi)\prod_{i:\pi(i)\neq i}a_{i,\pi(i)}$.

Using an interpolation argument, it can be shown that $p\mbox{-}\mathrm{det}$ is in $\mathbf{F}\mathbf{P}$ when $k$ is part of the input and thereby in $\mathbf{F}\mathbf{FPT}$ [13], the functional counterpart of $\mathbf{FPT}$. In fact, the same interpolation argument can be used to show that $p\mbox{-}\mathrm{det}$ is in ${\mathbf{Gap}\mathbf{L}}$ (the class of functions $f(x)$ such that for some $\mathbf{NL}$-machine, $f(x)$ is the number of accepting minus the number of rejecting paths). However, this does not give a space efficient algorithm for $p\mbox{-}\mathrm{det}$ in the sense of parameterised classes. The $\mathbf{Gap}\mathbf{L}$ algorithm may require a large number of nondeterministic steps and accordingly is not $k$-bounded. We show that the space efficient algorithm for the determinant given by Mahajan and Vinay [37] can be adapted to the parameterised setting, proving that $p\mbox{-}\mathrm{det}$ can be written as a difference of two $\#{\mathbf{para}}_{\beta}\mathbf{L}$ functions. Recall the notion of a clow sequence introduced by Mahajan and Vinay [37].

Definition 4.17** (Clow).**

*Let $\mathfrak{G}=(V,E)$ be a directed graph with $V=\{1,\ldots,n\}$ for some $n\in\mathbb{N}$. A clow in $\mathfrak{G}$ is a walk $C=(w_{1},\ldots,w_{r-1},w_{r}=w_{1})$ where $w_{1}$ is the minimal vertex among $w_{1},\dots,w_{r-1}$ with respect to the natural ordering of $V$ and $w_{1}\neq w_{j}$ for all $1<j<r$. Node $w_{1}$ is called the head of $C$, denoted by $\mathrm{head}(C)$. *

Definition 4.18** (Clow sequence).**

A clow sequence of a graph $\mathfrak{G}=(\{1,\dots,n\},E)$ is a sequence ${W}=(C_{1},\ldots,C_{k})$ such that $C_{i}$ is a clow of $\mathfrak{G}$ for $1\leq i\leq k$ and

• •

the heads of the sequence are in ascending order $\mathrm{head}(C_{1})<\cdots<\mathrm{head}(C_{k})$, and

• •

the total number of edges that appear in some $C_{i}$ (including multiplicities) is exactly $n$.

For a clow sequence $W$ of some graph $\mathfrak{G}=(\{1,\dots,n\},E)$ with $r$ clows the sign of $W$, $\mathrm{sign}(W)$, is defined as $(-1)^{n+r}$. Note that, if the clow sequence is a cycle cover $\sigma$, then $(-1)^{n+r}$ is equal to the sign of the permutation represented by $\sigma$ (that is, $(-1)^{\#\text{ inversions in }\sigma}$). Mahajan and Vinay came up with this sign-function to derive their formula for the determinant.

For an $(n\times n)$-matrix $A$, $\mathfrak{G}_{A}$ is the weighted directed graph with vertex set $\{1,\dots,n\}$ and weighted adjacency matrix $A$. For a clow (sequence) $W$, $\mathrm{weight}(W)$ is the product of weights of the edges (clows) in $w$. For any $\mathfrak{G}$ as above, $\mathcal{W}_{\mathfrak{G}}$ is the set of all clow sequences of $\mathfrak{G}$. Mahajan and Vinay [37] proved that $\det(A)=\sum_{W\in{\mathcal{W}_{\mathfrak{G}_{A}}}}\mathrm{sign}(W)\cdot\mathrm{weight}(W).$

We adapt these notions to the parameterised setting. First observe that for a permutation $\sigma\in S_{n,k}$, we have that $\mathrm{sign}(\sigma)=(-1)^{n+r}$, where $r$ is the number of cycles in the permutation. However, the number of cycles in $\sigma$ is $n-k+r^{\prime}$, where $r^{\prime}$ is the number of cycles of length at least two in $\sigma$. Accordingly, we have $\mathrm{sign}(\sigma)=(-1)^{2n-k+r^{\prime}}$. Adapting the definition of a clow sequence, for $k\geq 0$, define a $k$-clow sequence to be a clow sequence where the total number of edges (including multiplicity) in the sequence is exactly $k$, every clow has at least two edges, and no self loop edge of the form $(i,i)$ occurs in any of the clows. For any graph $\mathfrak{G}$ with vertex set $\{1,\dots,n\}$ for $n\in\mathbb{N}$, ${\mathcal{W}}_{\mathfrak{G},k}$ is the set of all $k$-clow sequences of $\mathfrak{G}$. For a $k$-clow sequence $W\in{\mathcal{W}}_{\mathfrak{G},k}$, $\mathrm{sign}(W)$ is $(-1)^{2n-k+r^{\prime}}$, where $r^{\prime}$ is the number of clows in $W$. Mahajan and Vinay [37, Theorem 1] showed that the signed sum of the weights of all clow sequences is equal to the determinant. At the outset, this is a bit surprising, since the determinant is equal to the signed sum of weights of cycle covers, whereas there are clow sequences that are not cycle covers. Mahajan and Vinay [37] observed that every clow sequence that is not a cycle cover can be associated with a unique clow sequence of opposite sign, and thereby all clow sequences cancel out. We observe a parameterised version of the above result [37, Theorem 1].

Lemma 4.19**.**

$p\mbox{-}\mathrm{det}(A,k)=\sum_{W\in{\cal W}_{\mathfrak{G}_{A},k}}\mathrm{sign}(W)\cdot\mathrm{weight}(W)$, for $\{0,1\}$-matrix $A$, $k\in\mathbb{N}$.

Using this characterisation, the upper bound in the following theorem can be obtained. For hardness a reduction from $\mathrm{p\text{-}}\#\mathrm{REACH}$ suffices.

Theorem 4.20**.**

The problem $p\mbox{-}\mathrm{det}$ for $(0,1)$-matrices can be written as a difference of two functions in $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$, and is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-hard with respect to $\leq^{\mathrm{plog}}_{\mathrm{met}}$.

5 Conclusions and Outlook

We developed foundations for the study of parameterised space complexity of counting problems. Our results show interesting characterisations for classes defined in terms of $k$-bounded para-logspace NTMs. We believe that our results will lead to further research of parameterised logspace counting complexity. Notice, that the studied walk problems in Section 4.1 can be considered restricted to DAGs yielding the same completeness results.

Branching programs are immanent for the study of space-bounded and parallel complexity classes. Languages accepted by polynomial-size logspace-uniform branching programs characterise $\mathbf{NL}$. In fact, this result carries forward to the counting versions. Motivated by this, one can consider parameterised counting classes based on deterministic branching programs (DBPs) and nondeterministic branching programs (BPs). It can be shown that for any $o\in\{\mathbf{W},\mathbf{W}[1],\beta,\beta\mbox{-}\mathbf{tail}\}$, $\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$ and $\#\mathbf{para}_{o}\mbox{-}\mathbf{NL}$, can be characterised in terms of an adequate parameterised counting version of DBPs and BPs, respectively (see Theorems B.6 and B.8 in the appendix).

Comparing our newly introduced classes with the $\mathbf{W}$-hierarchy (which is defined in terms of weighted satisfiability problems for circuits of a so-called bounded weft), one might ponder whether there is an alternative definition of our classes with such circuit problems. Though in this article we did not explore the weighted satisfiability, the closely related problem $p\text{-}\mathrm{MC}(\Sigma_{0})$ sheds some light on this. Theorem 4.13 shows that $p\text{-}\mathrm{MC}(\Sigma_{0})$ is complete for ${\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ (in fact, we show this for their counting versions) under $\leq^{\mathrm{plog}}_{m}$-reductions. However, if we take $\mathbf{FPT}$-reductions, $p\text{-}\mathrm{MC}(\Sigma_{0})$ is complete for $\mathbf{W}[1]$. Though we could not prove it so far, we believe this is a general phenomenon: Any $\mathbf{W}[1]$-complete problem is complete for ${\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ under $\leq^{\mathrm{plog}}_{m}$-reductions. More generally, there is a possibility that the FPT-closure of $\mathbf{para}_{W}\mathbf{L}$-classes is equal to the corresponding class in the $\mathbf{W}$-hierarchy.

One might also ask the question if $\mathbf{para}_{W}\mathbf{L}$ is contained in $\mathbf{F}\mathbf{FPT}$. This is unlikely based on the view expressed above. For example, $p\text{-}\mathrm{MC}(\Sigma_{0})$ is complete for both ${\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ and $\mathbf{W}[1]$ but under two different reductions. As a result, $\mathbf{para}_{W}\mathbf{L}\subseteq\mathbf{F}\mathbf{FPT}$ would imply that $p\text{-}\mathrm{MC}(\Sigma_{0})\in\mathbf{FPT}$ and, accordingly, $\mathbf{FPT}=\mathbf{W}[1]$ as $\mathbf{FPT}$ is closed under $\mathbf{FPT}$-reductions.

We close with interesting tasks for further research:

• •

Study further closure properties of the new classes (e.g., Open Problem 1).

• •

Improve the understanding of the influence of syntactic locality, resp., bounded arity in the setting of $\mathrm{p\text{-}}\#\mathrm{MC}(\Sigma_{0})$ (Open Problem 2).

• •

Find a characterisation of the $\leq^{\mathrm{plog}}_{\mathrm{pars}}$-closure of $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ (Open Problem 3).

• •

Identify a natural class of structures for which the homomorphism problem is $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$-complete (Open Problem 4).

• •

Establish a broader spectrum of complete problems for the classes ${\mathbf{para}}_{\beta}\mathbf{L}$ and $\mathbf{para}_{W}\mathbf{L}$, e.g., in the realm of satisfiability questions.

• •

Identify further characterisations of the introduced classes, e.g., in the vein of descriptive complexity, which could highlight their robustness.

• •

Study gap classes [28] based on our classes. This might help improve Theorem 4.20.

Appendix A Omitted Proof Details

Lemma 3.2.

For any $k$-bounded nondeterministic $\mathbf{para}\mathbf{L}$-machine $M$ there exists a $k$-bounded nondeterministic $\mathbf{para}\mathbf{L}$-machine $M^{\prime}$ with $\#\mathrm{acc}_{M}(x,k)=\#\mathrm{acc}_{M^{\prime}}(x,k)$ for all inputs $(x,k)$ such that $M^{\prime}$ has the following properties:

1. (1)

$M^{\prime}$* has a unique accepting configuration,* 2. (2)

on any input $(x,k)$, every computation path of $M^{\prime}$ accesses exactly $g(k)\cdot\log|x|$ nondeterministic bits (for some computable function $g$), and $M^{\prime}$ uses an extra tape (tape $S$) that counts the number of nondeterministic steps, and 3. (3)

$M^{\prime}$* has an extra tape (tape $C$) on which it remembers the last nondeterministic bits, resetting the tape after every $\log|x|$-many nondeterministic steps.*

Additionally, if $M$ has read-once access to its nondeterministic bits, or is tail-nondeterministic, or both, then $M^{\prime}$ also has these properties.

Proof A.1**.**

We construct the machine $M^{\prime}$ with the three desired properties and the same number of accepting computation paths as $M$ step by step, ensuring that the properties from previous steps are preserved.

First note that without loss of generality $M$ can be assumed to have a single accepting state. We can modify $M$ so that upon reaching an accepting state, it erases everything in the work tape and move the head positions of every tape to the left end marker. This ensures that $M$ has a unique accepting configuration, which is property (1). This does not alter the number of accepting paths of $M$ on any input.

To ensure (2), we construct a new machine $N$ that behaves as $M$ but additionally maintains a counter on tape $S$ for the access of nondeterministic bits: Every time a nondeterministic bit is accessed, the counter is incremented by $1$. If $M$ halts with the counter being less than $g(k)\cdot\log|x|$, then the modified machine $N$ keeps making nondeterministic choices until the count is $g(k)\cdot\log|x|$. We define $N$ to accept if and only if $M$ accepts and all of the additional nondeterministic bits guessed by $N$ have the value [math]. Note that $N$ does not use any additional space except for maintaining and updating the counter. For all $(x,k)\in\{0,1\}^{*}\times\mathbb{N}$, the machine $N$ accesses exactly $g(k)\cdot\log|x|$ nondeterministic bits on all computation paths and $\#\mathrm{acc}_{M}(x,k)=\#\mathrm{acc}_{N}(x,k)$. Also, $N$ still has property (1), since the tape $S$ has the same content and head position for all accepting configurations and the remaining part of accepting configurations doesn’t change compared to $M$.

Finally, to ensure (3), we modify $N$ from the previous step to obtain $M^{\prime}$ as follows. The new machine $M^{\prime}$ has an additional tape (tape $C$) on which it initially marks exactly $\log|x|$ cells, placing the head on the left-most cell afterwards. Whenever $N$ reads a nondeterministic bit, $M^{\prime}$ copies the nondeterministic bit to tape $C$ (that is, $M^{\prime}$ copies the bit to tape $C$ and moves the head position to the right). If the current head position in tape $C$ is on the right-most marked cell, then $M^{\prime}$ erases the content of tape $C$ in the marked cells and copies the nondeterministic bit currently being read to the first marked cell on tape $C$. Finally, $M^{\prime}$ accepts if and only if $N$ accepts. Since this modification does not introduce new nondeterministic steps, the number of accepting computation paths of $M^{\prime}$ on any input is the same as that of $N$ and the modification preserves property (2). To re-establish property (1), we clear tape $C$ whenever we reach an accepting configuration.

Theorem 3.3.

$\#{\mathbf{para}}_{\beta}\mathbf{L}\subseteq\mathbf{F}\mathbf{FPT}$.

Proof A.2**.**

Let $F\in\#{\mathbf{para}}_{\beta}\mathbf{L}$ via the machine $M$ with space-bound $g(k)+c\log n$ for some constant $c>0$. For an input $(x,k)$, let $\mathfrak{G}(x,k)=(V(x,k),E(x,k))$ be the configuration graph of $M$ on $(x,k)$. Since $|V(x,k)|=2^{O(g(k)+c\log|x|)}$, $\mathfrak{G}$ can be constructed in $\mathbf{FPT}$ time given the input $(x,k)$. Now, $\#\mathrm{acc}_{M}(x,k)$ is equal to the number of paths from the starting configuration $s(x,k)$ of $M$ on input $(x,k)$ to the unique accepting configuration $C_{\mathrm{acc}}$ (by virtue of Lemma 3.2). This can be done via a brute-force algorithm computing the number of accepting paths in $\mathfrak{G}(x,k)$, since the size of $\mathfrak{G}(x,k)$ is fpt and the branching degree of the vertices is at most $2$. That is, we systematically iterate through all paths starting from $s(x,k)$, storing the currently investigated path, and incrementing the count whenever we reach $C_{\mathrm{acc}}$.

Lemma 3.5.

The classes $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$ are closed under $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.

Proof A.3**.**

We start with $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$. Let $F,{F^{\prime}}\subseteq\{0,1\}^{*}\times\mathbb{N}$ and $F^{\prime}\in\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ via the $k$-bounded, $s_{F^{\prime}}$ space-bounded NTM $M_{F^{\prime}}$. Furthermore, let $F\leq^{\mathrm{plog}}_{\mathrm{pars}}{F^{\prime}}$ via the $\mathbf{para}\mathbf{L}$ oracle TM $M$. Let $\sigma\colon\{0,1\}^{*}\times\mathbb{N}\to\{0,1\}^{*}$ and $h\colon\{0,1\}^{*}\times\mathbb{N}\to\mathbb{N}$ such that the machine $M$ on input $(x,k)$ uses the only oracle query $(\sigma(x,k),h(x,k))$.

Let $M_{\sigma}$, $M_{h}$ with space-bounds $s_{\sigma}$, $s_{h}$ be the machines computing $\sigma$, $h$. To show that $F\in\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$, we construct a new ${\mathbf{para}}_{\mathbf{W}}\mathbf{L}$-machine $M_{F}$ as follows.

On input $(x,k)$, the machine $M_{F}$ simulates $M_{F^{\prime}}$ on $(\sigma(x,k),h(x,k))$ using $M_{\sigma}$ and $M_{h}$. Initially, $h(x,k)$ is computed using $M_{h}$ and the value is stored. Then, whenever $M_{F^{\prime}}$ reads the $i$-th input symbol, $M_{F}$ runs $M_{\sigma}$ on $(x,k)$ until it outputs the $i$-th symbol and uses it as the next input symbol. For this, note that $|σ(x,k)|$ is fpt-bounded. Afterwards $M_{F}$ continues the simulation of $M_{F^{\prime}}$. On $(x,k)$ the number of accepting paths of $M_{F}$ is exactly the number of accepting paths of $M_{F^{\prime}}$ on $(\sigma(x,k),h(x,k))$ which is equal to ${F^{\prime}}(\sigma(x,k),h(x,k))=F(x,k)$ as required. The space of $M_{F}$ is bounded by the space used by $M_{F^{\prime}}$ on $(\sigma(x,k),h(x,k))$ and space required for running $M_{\sigma}$ and bookkeeping. Regarding bookkeeping, we need an index counter for $M_{F^{\prime}}$’s input head position and the value $h(x,k)$. Formally, the space is bounded by

[TABLE]

where $s_{\text{bk}}(|x|,k)$ is the space required for bookkeeping. This sum is in $O(\log|x|+f(k))$.

The number of nondeterministic bits required by $M_{F}$ is the same as $M_{F^{\prime}}$ on input $(\sigma(x,k),h(x,k))$. Consequently, the computation of $M_{F}$ is still $k$-bounded as the number of nondeterministic bits is bounded by

[TABLE]

where $f^{\prime},f^{\prime\prime}$ are computable functions. This is due to $|\sigma(x,k)|$ being fpt-bounded and $h(x,k)$ being bounded by a computable function in $k$.

We continue with $\#{\mathbf{para}}_{\beta}\mathbf{L}$. The proof is analogous but $M_{F^{\prime}}$ has read-once access to its nondeterministic bits. Now, the only time $M_{F}$ accesses nondeterministic bits is when $M_{F^{\prime}}$ accesses its nondeterministic bits. This simulation also preserves the order in which nondeterministic bits are accessed. So $M_{F}$ has read-once access to its nondeterministic bits as well.

Theorem 3.6.

For any $o\in\{\mathbf{W},\mathbf{W}[1],\beta,\beta\mbox{-}\mathbf{tail}\}$, the class $\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$ is closed under addition and multiplication.

Proof A.4**.**

Let $F_{1},F_{2}$ be in $C$ via the NTMs $M_{1}$ and $M_{2}$, respectively. We start by showing that the above classes are closed under addition. We first consider $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$. The argument is similar for both of the classes. We give details for $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$. We construct a new machine $M$ as follows: $M$ nondeterministically chooses whether to simulate the machine $M_{1}$ or the machine $M_{2}$ on the given input using a single additional nondeterministic bit. By construction we have $\#\mathrm{acc}_{M}(x,k)=\#\mathrm{acc}_{M_{1}}(x,k)+\#\mathrm{acc}_{M_{2}}(x,k)=F_{1}(x,k)+F_{2}(x,k)$. Also, $M$ is $O(\log|x|+h(k))$ space-bounded and $k$-bounded since it only behaves in the same way as either $M_{1}$ or $M_{2}$ and uses one additional (nondeterministic) step in the beginning.We conclude that the class $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ is closed under addition. Exactly the same argument works for $C={\mathbf{para}}_{\beta}\mathbf{L}$.

For $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$, we modify $M$ as follows: $M$ first simulates the deterministic parts up until the first nondeterministic step of both machines $M_{1}$ and $M_{2}$. We then choose nondeterministically whether to finish the computation of $M_{1}$ or $M_{2}$. This ensures that $M$ is tail-nondeterministic if $M_{1}$ and $M_{2}$ are tail-nondeterministic. Also, read-once access to nondeterministic bits is still preserved.

We now show that the above classes are closed under multiplication, starting again with $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta}\mathbf{L}$. We construct a new machine $M^{\prime}$. On input $(x,k)$, $M^{\prime}$ first simulates $M_{1}$ on input $(x,k)$. If $M_{1}$ accepts, then $M^{\prime}$ simulates $M_{2}$ on $(x,k)$, and accepts if and only if $M_{2}$ does so. Since $M_{1}$ and $M_{2}$ are $k$-bounded, $M^{\prime}$ is also $k$-bounded. The space used by $M^{\prime}$ is at most the maximum of that of $M_{1}$ and $M_{2}$. By construction we have $\#\mathrm{acc}_{M^{\prime}}(x,k)=\#\mathrm{acc}_{M_{1}}(x,k)\cdot\#\mathrm{acc}_{M_{2}}(x,k)=F(x,k)\cdot F^{\prime}(x,k)$. Accordingly, the class $C=\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ is closed under multiplication. Additionally, if $M_{1}$ and $M_{2}$ only have read-once access to the nondeterministic bits, so has the new machine $M^{\prime}$. We conclude that $\#{\mathbf{para}}_{\beta}\mathbf{L}$ is closed under multiplication.

For $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$, we modify $M^{\prime}$ similar to what was done to show that these classes are closed under addition. $M^{\prime}$ first simulates the deterministic parts up until the first nondeterministic step of both machines $M_{1}$ and $M_{2}$. Then $M^{\prime}$ simulates $M_{1}$ starting from the first nondeterministic step. If $M_{1}$ accepts, $M^{\prime}$ simulates $M_{2}$ starting from the first nondeterministic step and accepts if and only if $M_{2}$ accepts. Formally, let $C_{1}$ be the first nondeterministic configuration of $M_{1}$ on input $(x,k)$ and $C_{2}$ be the first nondeterministic configuration of $M_{2}$ on $(x,k)$. The new machine $M^{\prime}$ runs $M_{1}$ on $(x,k)$ until the configuration $C_{1}$ is reached. Then $M^{\prime}$ stores the configuration $C_{1}$ and runs $M_{2}$ on $(x,k)$ until the configuration $C_{2}$ is reached. Storing $C_{2}$ in a separate tape, $M^{\prime}$ now proceeds with the nondeterministic computation of $M_{1}$ starting with the configuration $C_{1}$. For every accepting configuration of $M_{1}$, the machine $M^{\prime}$ re-starts the computation of $M_{2}$ starting from configuration $C_{2}$ accepting on all paths where $M_{2}$ does. By construction, the machine $M^{\prime}$ accepts $(x,k)$ if and only if $M_{1}$ and $M_{2}$ both accept it. As a result, we have $\#\mathrm{acc}_{M^{\prime}}(x,k)=\#\mathrm{acc}_{M_{1}}(x,k)\cdot\#\mathrm{acc}_{M_{2}}(x,k)=F(x,k)\cdot F^{\prime}(x,k).$

Suppose $M_{1}$ and $M_{2}$ are both tail-nondeterministic. Then the number of steps of $M_{1}$ (respectively $M_{2}$) starting from configuration $C_{1}$ (respectively $C_{2}$) is $k$-bounded. The machine $M^{\prime}$ does not perform any nondeterministic steps until it starts simulating $M_{1}$ from configuration $C_{1}$. By the tail-nondeterminism of $M_{1}$, the number of steps starting from $C_{1}$ until its termination is $k$-bounded. Once $M_{1}$ terminates, $M^{\prime}$ starts simulation of $M_{2}$ starting from $C_{2}$ on all accepting computations of $M_{1}$. The computation of $M_{2}$ starting from the configuration $C_{2}$ is also $k$-bounded. This ensures that if both $M_{1}$ and $M_{2}$ are tail-nondeterministic, so is $M^{\prime}$. Also, it can be seen that the read-once access to nondeterministic bits is preserved.

Theorem 4.1.

For every $b\geq 2$, $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{b}$ is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$-reductions.

Proof A.5**.**

Algorithm 1 shows membership. The algorithm first checks the constraint on $a$. Then it starts from vertex $s$ and guesses an arbitrary path of length exactly $a$, using the fact that the out-degree of all vertices is bounded by $b$ to limit the number of nondeterministic bits needed for this task. More precisely, we choose a natural ordering depending on the encoding of vertices and use this to reference successors of the current node by numbers $0,\dots,b-1$. The needed number of nondeterministic bits is $a\cdot\log(b)\in O(k\cdot\log|V|)$. Furthermore, at any point of time, indices of at most two vertices as well as one number bounded by a constant are stored, so the algorithm uses logarithmic space.

Regarding the lower bound, let $F\in\#{\mathbf{para}}_{\beta}\mathbf{L}$ via the machine $M$. Using Lemma 3.2, we can assume that $M$ has a unique accepting configuration $C_{\mathrm{acc}}$ and there is a computable function $f$ such that for any input $(x,k)$ all accepting computation paths of $M$ on input $(x,k)$ use exactly $f(k)\cdot\log|x|$ nondeterministic bits. Let $(x,k)$ be an input of $M$. Consider the graph $\mathfrak{G}(x,k)=(V(x,k),E(x,k))$ where $V(x,k)$ is the set containing all nondeterministic configurations of $M$ on input $(x,k)$ as well as $C_{\mathrm{acc}}$ and $E(x,k)$ contains an edge $(C,C^{\prime})$ if and only if $C^{\prime}$ is reached from $C$ using exactly one nondeterministic step and any number of deterministic steps in the computation of $M$ on input $(x,k)$. Now the number of accepting computation paths of $M$ on input $(x,k)$ is exactly the number of paths of length $f(k)\cdot\log|x|$ from the first nondeterministic configuration $s(x,k)$ reached in the computation of $M$ on input $(x,k)$ to the unique accepting configuration in $\mathfrak{G}$. To ensure that the length of accepting paths is bounded by $f(k)\cdot\log|\mathfrak{G}|$, we further assume, without loss of generality, that $|V(x,k)|\geq|x|$.

Note that no (directed) cycle is reachable from the initial configuration in the configuration graph of $M$ on any input. For that reason no cycle is reachable from $s(x,k)$ in $\mathfrak{G}$ and hence every $s$-$t$-walk in $\mathfrak{G}$ is an $s$-$t$-path. We now have for all $(x,k)$ that

[TABLE]

Adjacency within $\mathfrak{G}(x,k)$ can be computed from $(x,k)$ in parameterised logspace, since it only depends on the (fixed) machine $M$ as well as computing deterministic paths. Furthermore, the new parameter is bounded by a computable function in the old parameter. Accordingly, the construction yields a para-logspace parsimonious reduction.

Theorem 4.3.

$\mathrm{p\text{-}}\#\mathrm{REACH}$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.6**.**

Regarding membership, we modify Algorithm 1. Line 1 is omitted. In line 1, we now loop over $i$ from $1$ to $k$ and in line 1 we guess a number between $1$ and $\log|V|$. This number is used to choose a successor $v_{2}$ of $v_{1}$.

Regarding hardness, let $F\in\#{\mathbf{para}}_{\beta}\mathbf{L}$ via the machine $M$. Without loss of generality, $M$ is in the normal form from Lemma 3.2 and there is a computable function $f$ such that $M$ on any input $(x,k)$ uses exactly $f(k)\cdot\log|x|$ nondeterministic bits. Also assume without loss of generality that the accepting configuration of $M$ is deterministic. Fix an input $(x,k)$. We reduce the problem of counting the accepting computation paths of $M$ on input $(x,k)$ to the problem of counting walks in a modified version of the configuration graph of $M$ on input $(x,k)$. The difference to the hardness proof of Theorem 4.1 is that edges now encode computations comprised of $\log|x|$-many nondeterministic steps. More precisely, define $\mathfrak{G}=(V,E)$ and $s,t\in V$ as follows: $V$ consists of all nondeterministic configurations of $M$ on input $(x,k)$ and the (unique) accepting configuration $C_{\mathrm{acc}}$ of $M$. For $C^{\prime}\neq C_{\mathrm{acc}}$, $(C,C^{\prime})\in E$ if and only if configuration $C^{\prime}$ is reachable from $C$ in exactly $\log|x|$-many nondeterministic steps (and any number of deterministic steps) in the computation of $M$ on input $(x,k)$. Furthermore, $(C,C_{\mathrm{acc}})\in E$ if and only if $C_{\mathrm{acc}}$ is reachable from $C$ using only deterministic steps in the computation of $M$ on input $(x,k)$. Finally, $s$ is the first nondeterministic configuration reached in the computation of $M$ on input $(x,k)$ and $t=C_{\mathrm{acc}}$.

Since all accepting computation paths in the configuration graph of $M$ on input $(x,k)$ use exactly $f(k)\cdot\log|x|$ nondeterministic bits, the change made compared to the reduction used for Theorem 4.1 does not change the number of paths and we can simply count paths of length exactly $f(k)$ in the new graph. By the above we have

[TABLE]

The set $E$ can still be computed by a $\mathbf{para}\mathbf{L}$-machine: To check whether an edge $(C,C^{\prime})$ is present, we simply loop over all values for the next $\log|x|$ nondeterministic bits and verify whether the corresponding sequence of configurations starting from $C$ is a path ending in $C^{\prime}$ in the configuration graph of $M$ on input $(x,k)$. Consequently, the construction yields a para-logspace parsimonious reduction.

Theorem 4.4.

$\mathrm{p\text{-}}\#\mathrm{REACH}$* is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.7**.**

This almost immediately follows from the proof of Theorem 4.3. For membership, observe that the runtime of the modified algorithm described in that proof is bounded by $O(k\cdot\log n)$ and hence the algorithm is already tail-nondeterministic. For hardness, it suffices that the problem is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-hard and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}\subseteq\#{\mathbf{para}}_{\beta}\mathbf{L}$.

Theorem 4.6.

$\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{T}$.*

Proof A.8**.**

For membership, we use Algorithm 1 but nondeterministically guess nodes $s,t\in V$.

For hardness, let $F\in\mathrm{p\text{-}}\#{\mathbf{para}}_{\beta}\mathbf{L}$ via the machine $M$. Without loss of generality assume that $M$ has a unique accepting configuration and that there is a computable function $f$ such that $M$ on input $(x,k)$ uses exactly $f(k)\cdot\log|x|$ nondeterministic bits.

Similarly as in the proof of Theorem 4.1, let $\mathfrak{G}(x,k)=(V(x,k),E(x,k))$ be the configuration graph such that all paths through only deterministic configurations are substituted by a single edge. Furthermore, we extend $\mathfrak{G}(x,k)$ such that we add a path of fresh vertices $v_{1},\dots,v_{\log|x|}$ with $(v_{i},v_{i+1})\in E(x)$ for $1\leq i<\log|x|$. The reason for this construction lies in possible “bad” sequences of configurations as depicted in Figure 2.

Furthermore, without loss of generality we assume $|V(x,k)|\geq|x|$. Now, any path in $\mathfrak{G}(x,k)$ going from $v_{1}$ to the initial configuration $s(x,k)$ and then to the accepting configuration $t$ is of length $\ell\mathrel{\mathop{:}}=(f(k)+1)\cdot\log|x|$. Notice, that the number of such $v_{1}$-$t$-paths is equivalent to the number of accepting paths of $M$ on input $x$. To precisely calculate $\#\mathrm{acc}_{M}(x,k)$, we will use two oracle queries to different $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}$-instances yielding a $\leq^{\mathrm{plog}}_{T}$-reduction as required.

At first, we compute the result $n_{1}$ of the oracle query $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}(\mathfrak{G}(x,k),\ell,f(k)+1)$. Then, we modify $\mathfrak{G}(x,k)$ yielding a graph $\mathfrak{G}^{\prime}(x,k)$ by deleting the edge $(v_{1},v_{2})$. This ensures that in $\mathfrak{G}^{\prime}(x,k)$ among paths of length $(f(k)+1)\cdot\log|x|$ exactly the “good” accepting paths are missing compared to $\mathfrak{G}(x,k)$. Then we store the value of the oracle query $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{WALK}_{b}(\mathfrak{G}^{\prime}(x,k),\ell,f(k)+1)$ in the variable $n_{2}$. Finally, calculate the difference $n_{1}-n_{2}$ which is equivalent to $\#\mathrm{acc}_{M}(x,k)$.

Theorem 4.7.

$\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{2}\text{-}\mathrm{CNF}$* is $\#\mathbf{para}_{W}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.9**.**

Regarding membership, we can modify Algorithm 1 to find paths as before. We then need to check whether the chosen path also satisfies the formula φ. For this, we do the following. First, we use the folklore logspace-algorithm for propositional model-checking. Then, whenever we need the value of a variable $e$, we re-compute the whole path constructed using Algorithm 1 reusing the nondeterministic bits and check whether the edge $e$ is used in that path (when $e$ occurs, then the computation can be stopped and the variable $e$ is true; when the computation terminates without $e$ occurring, then the variable $e$ is false). This yields a $\#\mathbf{para}_{W}\mathbf{L}$-algorithm.

Regarding hardness, we use the same construction as in the proof of Theorem 4.1. The difference is that nondeterministic bits can be reused. This means that we need to ensure to only count paths on which different queries to the same nondeterministic bit assume the same value for that bit. Let $\mathfrak{G}(x,k)=(V(x,k),E(x,k))$, $s(x,k)$, $t$ and $f$ be as in the proof of Theorem 4.1. Let $\ell\colon E(x,k)\to\mathbb{N}$ be a labelling function stating which nondeterministic bit is read on each edge of $\mathfrak{G}(x,k)$ and let $\textrm{val}\colon E(x,k)\to\{0,1\}$ be a function mapping each edge to the value of the corresponding nondeterministic bit assumed in the computation when using that edge. We can now define

[TABLE]

expressing that the values assumed for the nondeterministic bits are consistent throughout a path. Notice that $φ(x,k)$ can be computed in parameterised logspace. Hence, the mapping

[TABLE]

is a para-logspace parsimonious reduction.

Theorem 4.9.

$\mathrm{p\text{-}}\#\mathrm{CC}_{2}\text{-}\mathrm{CNF}$* is $\#\mathbf{para}_{W}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.10**.**

The following algorithm shows membership. Let the input be the directed graph $\mathfrak{G}=(V,E)$, the CNF-formula $φ$ and $a,k\in\mathbb{N}$. Guess distinct vertices $v_{1},\dots,v_{\ell}\in V$ where $\ell\leq k$. These are supposed to be vertices from distinct cycles in the cycle cover. Now, for each $v_{i}$ guess a walk from that vertex to itself not containing any vertex whose encoding is lexicographically smaller than that of $v_{i}$. Reusing nondeterministic bits, it can be assured that no vertex is visited twice. In the above procedure, count the number of visited vertices. If that number is $k\cdot a$, then accept. This way, each accepting path corresponds to a distinct cycle cover of $\mathfrak{G}$ with the desired properties.

For hardness, we proceed similarly as for $\mathrm{p\text{-}}\#\mathrm{LOG}\mathrm{REACH}_{2}\text{-}\mathrm{CNF}$ in the proof of Theorem 4.7. Let $\mathfrak{G}(x,k)=(V(x,k),E(x,k)),s(x,k),t$ and $f$ be defined as in the proof of that theorem. Now let $\mathfrak{G}^{\prime}(x,k)$ be the graph $\mathfrak{G}(x,k)$ with added self-loops for all vertices except $s(x,k)$ and $t$, as well as the additional edge $(t,s(x,k))$. In $\mathfrak{G}(x,k)$, the component reachable from $s(x,k)$ does not contain any cycles. Furthermore, $s(x,k)$ does not have a self-loop in $\mathfrak{G}^{\prime}(x,k)$. For these reasons, the edge $(t,s(x,k))$ is contained in any cycle cover of $\mathfrak{G}^{\prime}(x,k)$. The cycle containing this edge always consists of this edge as well as a path from $s(x,k)$ to $t$, that is, an accepting computation path. By construction, all accepting computation paths have length exactly $f(k)\cdot\log|x|$. For this reason, we can simply choose $k^{\prime}=f(k)$ and $a=\log|x|$. Now cycle covers of $\mathfrak{G}^{\prime}(x,k)$ with $\leq f(k)$ non-self-loop-cycles and exactly $k\cdot a$ non-trivially covered vertices cover exactly one accepting computation path non-trivially and cover all other vertices by self-loops. Finally, $φ(x,k)$ is chosen as in the proof of Theorem 4.7.

The desired reduction function is $(x,k)\mapsto((\mathfrak{G}^{\prime}(x,k),φ(x,k),f(k)\cdot\log|x|),f(k))$.

Theorem 4.11.

For $a\geq 2,r\geq 1$, $\mathrm{p\text{-}}\#\mathrm{MC}(\Sigma_{0}^{r\text{-local}})_{a}$ is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.

Proof A.11**.**

We show both completeness-results by showing membership in $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$ and hardness for $\#{\mathbf{para}}_{\beta}\mathbf{L}$.

For membership, let $φ\in{\Sigma_{0}^{r\text{-local}}}_{a}$ be a formula over some vocabulary σ, $\mathbf{A}$ be a σ-structure and $k\in\mathbb{N}$. Without loss of generality, $|φ|\leq k$, since we can immediately reject otherwise. When evaluating φ in $\mathbf{A}$ in a topdown-fashion, book-keeping only needs space bounded by a computable function in $k$, since $|φ|\leq k$. With the naive approach, we need more than logarithmic space to store the first-order assignment. To avoid this, we use the fact that φ is $r$-local and the arity of relation symbols occurring in φ is bounded by $a$. We nondeterministically guess the assignment for any first-order variable in φ when we first encounter an atom involving that variable and due to $r$-locality we can discard it after evaluating the next $r$ atoms. This means that at any point during the computation, we store an assignment only for the variables that occurred in the previous $r$ atoms, that is, for at most $a\cdot r$ variables. Note that we evaluate φ node by node and for each node only have to process a constant number of elements of $\mathrm{dom}(\mathbf{A})$, which are of logarithmic length. Since $|φ|\leq k$, this means that the runtime of the whole procedure is bounded by $f(k)\cdot\log|\mathbf{A}|$ for some computable function $f$ and hence the procedure is tail-nondeterministic.

To show hardness, we reduce from $\mathrm{p\text{-}}\#\mathrm{REACH}$, which is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete by Theorem 4.3. Define the vocabulary $σ\mathrel{\mathop{:}}=(E,s,t)$. Fix an input $((\mathfrak{G}=(\textsf{V},\textsf{E}),\textsf{s},\textsf{t}),k)$ of $\mathrm{p\text{-}}\#\mathrm{REACH}$. The formula

[TABLE]

expresses that a tuple of vertices $(v_{1},\dots,v_{k})$ is an $s^{\mathbf{A}}$-$t^{\mathbf{A}}$-walk in the input structure $\mathbf{A}$. We define the σ-structure $\mathbf{G}$ as $(\textsf{V},\textsf{E},\textsf{s},\textsf{t})$. By construction, the number of satisfying assignments of φ in structure $\mathbf{G}$ is exactly the number of s-t-paths of length $k$ in $\mathfrak{G}$. Also, $|φ|$ is bounded by $k$. As a result, the mapping $((\mathfrak{G},\textsf{s},\textsf{t}),k)\mapsto((φ_{k},\mathbf{G}),|φ|)$ is the desired reduction.

Theorem 4.13.

$p\text{-}\#\mathrm{MC}(\Sigma_{0})$* is $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.12**.**

Regarding membership in $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$, let $\varphi(x_{1},\dots,x_{n})\in\Sigma_{0}$ be a σ-formula and ${\mathbf{A}}$ be a σ-structure. Furthermore, let $A$ be the universe of $\mathbf{A}$. The counting machine for $|\varphi({\mathbf{A}})|$ can be described as follows. Nondeterministically guess assignments for $x_{1},\ldots,x_{k}$ from $A$ and verify if $\varphi$ is true under the guessed assignments. The resulting machine is $k$-bounded, tail-nondeterministic (c.f. the proof of Theorem 4.11) and uses space at most $O(|\varphi|+\log n)$, where $n=|{\mathbf{A}}|$.

Regarding hardness, let $F\in\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}$ and $M$ be a $k$-bounded $O(\log|x|+g(k))$ space-bounded NTM, with access to $g(k)\cdot\log|x|$ nondeterministic bits. Without loss of generality, assume that $M$ is in the normal form from Lemma 3.2.

Let $σ=(V,R,C_{0},C_{\mathrm{acc}})$. Fix an input $(x,k)$. We define a $σ$-structure $\mathbf{A}$ from the configuration graph of $M$ on input $(x,k)$. Let $V^{\mathbf{A}}$ be the set of all nondeterministic configurations of $M$ on input $(x,k)$ along with the accepting configuration, $C_{0}^{\mathbf{A}}$ be the first nondeterministic configuration of $M$ on input $(x,k)$ and $C_{\mathrm{acc}}^{\mathbf{A}}$ be the accepting configuration of $M$. Let $R^{\mathbf{A}}$ be a relation with arity $g(k)+2$ such that $R^{\mathbf{A}}(C_{1},C_{2},b_{1},\ldots,b_{g(k)})$ is true if an only if $M$ reaches configuration $C_{2}$ from $C_{1}$ using exactly $g(k)\cdot\log|x|$ nondeterministic steps with $b_{1}\circ\dots\circ b_{g(k)}$ as the content of the choice tape. Here, $b_{i}\in\{0,1\}^{\log|x|}$ for all $i$. Given $C_{1},C_{2}$ and numbers $b_{1},\ldots,b_{g(k)}\in\{1,\ldots,|x|\}$, testing if $R^{\mathbf{A}}(C_{1},C_{2},b_{1},\ldots,b_{g(k)})$ is true or not can be done in $\mathbf{para}\mathbf{L}$. Now, let $\mathrm{dom}(\mathbf{A})=\{1,\ldots,|x|\}\cup V$ and define the following $σ$-formula:

[TABLE]

Note that φ has $2\cdot g(k)$ free variables. For any assignment to the free variables, φ is true if and only if the assignment to $z_{1},\ldots,z_{g(k)}$ represents a nondeterministic choice that leads to acceptance and the assignment to $x_{1},\ldots,x_{g(k)}$ represents the corresponding sequence of configurations. In fact, given an assignment to $z_{1},\ldots,z_{g(k)}$, if $M$ accepts along this nondeterministic path, then there is a unique assignment to the variables $x_{1},\ldots,x_{g(k)}$ that satisfies the formula φ.

Combining the above observations with the arguments used in the proofs of Theorems 4.3 and 4.11, we conclude that $\#\mathrm{acc}_{M}(x,k)=|φ({\mathbf{A}})|$. Given $(x,k)$, the structure ${\mathbf{A}}$ and φ can be computed in $\mathbf{para}\mathbf{L}$ by similar arguments as before. This completes the proof.

Theorem 4.16.

$\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{P}^{*})$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.13**.**

Regarding membership, we will show $\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{P}^{*})\leq^{\mathrm{plog}}_{\mathrm{pars}}\mathrm{p\text{-}}\#\mathrm{REACH}$, where the latter is in $\#{\mathbf{para}}_{\beta}\mathbf{L}$ by Theorem 4.3. The proof idea is visualised in Figure 3 with an example. Consider an arbitrary input $((\mathbf{A},\mathbf{B}),k)$ to $\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{P}^{*})$ with $\mathrm{FO}$-structures $\mathbf{A},\mathbf{B}$ and $k\in\mathbb{N}$. By definition of the problem we have $\mathbf{A}\in\mathcal{P}^{*}$. Let $A=\mathrm{dom}(\mathbf{A}),B=\mathrm{dom}(\mathbf{B})$. We assume that $\mathbf{A}$ and $\mathbf{B}$ have the same underlying vocabulary σ and $|A|\leq k$, since the remaining cases can easily be handled. Let $E$ be the edge relation symbol in σ. Furthermore, let $A=\{a_{1},\dots,a_{n}\}$ with $n\in\mathbb{N}$ be the universe of $\mathbf{A}$ such that $(a_{i},a_{i+1})\in E^{\mathbf{A}}$ and let $B$ be the universe of $\mathbf{B}$.

Now, define the directed graph $\mathfrak{G}=(B\cup\{s,t\},E^{\prime})$ with $s,t\notin B$ and

[TABLE]

The reduction is given by the mapping $((\mathbf{A},\mathbf{B}),k)\mapsto((\mathfrak{G},s,t),|A|+2)$.

We show correctness by giving a $1$-$1$-correspondence between homomorphisms from $\mathbf{A}$ to $\mathbf{B}$ and $s$-$t$-walks in $\mathfrak{G}$ of length $|A|+2$. This correspondence is given by the following mapping. Let $h$ be a homomorphism from $\mathbf{A}$ to $\mathbf{B}$. This homomorphism is bijectively mapped to an $s$-$t$-path as follows. The homomorphism yields a sequence $(h(a_{1}),\dots,h(a_{n}))$ with $h(a_{i})\in C_{a_{i}}^{\mathbf{B}}$, $(h(a_{i}),h(a_{i+1}))\in E^{\mathbf{B}}$ for $1\leq i<n$. From this, we obtain the $s$-$t$-path $(s,h(a_{1}),\dots,h(a_{n}),t)$ in $\mathfrak{G}$.

Regarding injectivity, let $h\neq h^{\prime}$ be two different homomorphisms from $\mathbf{A}$ to $\mathbf{B}$. As a result, there exists an $1\leq i<n$ such that $h(a_{i})\neq h^{\prime}(a_{i})$. Consequently, $(s,h(a_{1}),\dots,h(a_{n}),t)\neq(s,h^{\prime}(a_{1}),\dots,h^{\prime}(a_{n}),t)$.

Regarding surjectivity, let $(s,v_{1},\dots,v_{n},t)$ be an $s$-$t$-path in $\mathfrak{G}$. Now, $(s,v_{1})$, $(v_{i},v_{i+1})$, $(v_{n},t)\in E^{\prime}$ with $1\leq i<n$. By construction of $E^{\prime}$, this means $v_{i}\in C_{a_{i}}^{\mathbf{B}}$ for $1\leq i\leq n$ and $(v_{i},v_{i+1})\in E^{\mathbf{B}}$ for $1\leq i<n$. Consequently, the function $h$ with $h(a_{i})=v_{i}$ for all $i$ is a homomorphism from $\mathbf{A}$ to $\mathbf{B}$ and $h$ is a preimage of $(s,v_{1},\dots,v_{n},t)$ under the given mapping.

The reduction can be computed by a $\mathbf{para}\mathbf{L}$-machine as follows. The vertex set of the graph is just the universe $B$ extended by two new vertices. Store the sequence $a_{1},\dots,a_{n}$. To compute $E^{\prime}$, the machine identifies all vertices $x\in C_{a_{1}}^{\mathbf{B}}$ and prints for each the edge $(s,x)$; similarly for all edges $(x,t)$ with $x\in C_{a_{n}}^{\mathbf{B}}$. Then, for each edge $(x,y)\in E^{\mathbf{B}}$, we find and store the index $i$ such that $x\in C_{a_{i}}^{\mathbf{B}}$ and check whether $y\in C_{a_{i+1}}^{\mathbf{B}}$ is true. The machine only queries relations of $\mathbf{B}$ for individual tuples which can be achieved with binary counters.

Regarding the lower bound, we first introduce a coloured variant $\mathrm{p\text{-}}\#\mathrm{REACH}^{*}$ of $\mathrm{p\text{-}}\#\mathrm{REACH}$ as follows. Here, a colouring function $\ell\colon V\to\{1,\dots,m\}$ for some $m\in\mathbb{N}$ is given as an additional part of the input.

[TABLE]

The $\#{\mathbf{para}}_{\beta}\mathbf{L}$-hardness with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$ can be shown similarly to the one of $\mathrm{p\text{-}}\#\mathrm{REACH}$ (as in the proof of Theorem 4.3) as follows, see Lemma A.14 (the next result below) for details. The inputs $\mathfrak{G},s,t$ and $k$ can be constructed in the same way whereas the colouring function $\ell$ can be defined as follows. For each configuration $v\in V$, define $\ell(v)$ as the content of tape $S$, which is the value of the step counter. By definition of $\ell$, all $s$-$t$-paths respect the colouring.

Now, we show $\mathrm{p\text{-}}\#\mathrm{REACH}^{*}\leq^{\mathrm{plog}}_{\mathrm{pars}}\mathrm{p\text{-}}\#\mathrm{Hom}(\mathcal{P}^{*})$. Given a directed graph $\mathfrak{G}=(V,E)$, $s,t\in V$, $k\in\mathbb{N}$, $\ell\colon V\to\{1,\dots,k\}$, we define two structures $\mathbf{A},\mathbf{B}$ as follows. Let the universe of $\mathbf{A}$ be defined as $\{1,\dots,k\}$, $E^{\mathbf{A}}\mathrel{\mathop{:}}=\{\,(i,i+1),(i+1,i)\mid 1\leq i<k\,\}$, and $C_{i}^{\mathbf{A}}\mathrel{\mathop{:}}=\{i\}$ for $1\leq i\leq k$. Define the universe of $\mathbf{B}$ as $V$, $E^{\mathbf{B}}\mathrel{\mathop{:}}=\{\,(u,v),(v,u)\mid(u,v)\in E\,\}$, and $C_{i}^{\mathbf{B}}\mathrel{\mathop{:}}=\{\,u\mid\ell(u)=i\,\}$.

Regarding correctness, the function that maps each $s$-$t$-path $\pi=(s=v_{1},\dots,v_{k}=t)$ to the homomorphism $h_{\pi}$ with $h_{\pi}(i)=v_{i}$ for all $1\leq i\leq k$ is a bijective mapping between colour-respecting $s$-$t$-paths $\pi$ in $\mathfrak{G}$ and homomorphisms $h_{\pi}$ from $\mathbf{A}$ to $\mathbf{B}$. For this, note that the colouring $\ell$ ensures that the direction of edges in the original graph is respected even for edges that are not part of actual computation paths on the current input. This is due to the fact that the step counter is added for any transition of the TM. The mapping is injective due to the fact that each node in the path contributes to the construction of the homomorphism. The mapping is surjective as for each homomorphism $h$ the path $(h(1),\dots,h(k))$ is a colour-respecting $s$-$t$-path in $\mathfrak{G}$ and a preimage of $h$.

Regarding ${\mathbf{para}}_{\beta}\mathbf{L}$-computability, $\mathbf{A}$ relies only on the parameter. The universe of structure $\mathbf{B}$ is a copy, $E^{\mathbf{B}}$ is a symmetric closure of $E$, and the $C_{i}^{\mathbf{B}}$ require a $\log|V|$-counter to check for each $u\in V$ whether $\ell(u)=i$. This completes the proof.

Lemma A.14**.**

$\mathrm{p\text{-}}\#\mathrm{REACH}^{*}$* is $\#{\mathbf{para}}_{\beta}\mathbf{L}$-complete with respect to $\leq^{\mathrm{plog}}_{\mathrm{pars}}$.*

Proof A.15** (Sketch).**

The proof is very similar to that of Theorem 4.3. Regarding hardness, we outline the main difference and the process of labeling the vertices. Let $F\in\#{\mathbf{para}}_{\beta}\mathbf{L}$ via a $k$-bounded $\log$-space NTM $M$ which has read-once access to nondeterministic bits. Consider an input $(x,k)$ and let $\mathfrak{G}=(V,E)$ be the configuration graph of $M$ as defined in the proof of Theorem 4.3. For a nondeterministic configuration $C\in V$, let $\ell(C)$ be the number represented in tape S in the configuration $C$. Now it is not hard to see that $F(x,k)=\mathrm{p\text{-}}\#\mathrm{REACH}^{*}(\mathfrak{G},s,t,\ell)$, where $s$ is the first nondeterministic configuration reachable from the initial configuration of $M$ on $(x,k)$ and $t$ is the unique accepting configuration of $M$.

Lemma 4.19.

For all $(0,1)$-matrices $A$ and $k\in\mathbb{N}$ it holds that

[TABLE]

Proof A.16**.**

The statement essentially follows from the arguments of Mahajan and Vinay [37, Theorem 1] and reader is referred to the original article for a full construction. Their proof involves defining an involution $\eta$ (i.e., $\eta$ is a bijection whose inverse is itself) on the set of clow sequences such that $\eta$ is the identity on the set of all cycle covers (i.e., $\eta(C)=C$ for any cycle cover $C$) and for any clow sequence $W$ that is not a cycle cover, we have $\mathrm{sign}(W)=-\mathrm{sign}(\eta(W))$.

We briefly describe the involution $\eta$ given by Mahajan and Vinay [37]. For a clow sequence ${W}=(W_{1},\ldots,W_{r})$, the clow sequence $\eta({W})$ is obtained from $W$ as follows. Let $i\in\{1,\dots,r\}$ be the smallest index such that clows $W_{i+1},\ldots,W_{r}$ are vertex disjoint simple cycles. Traverse the clow $W_{i}$ starting from the head until we reach some vertex $v$ such that either $v$ is in some $W_{j}$ for $i+1\leq j\leq r$ or $v$ completes a simple cycle within $W_{i}$. In the former case, we merge the simple cycle $W_{j}$ with the clow $W_{i}$ and remove $W_{j}$ from the sequence to get the clow sequence $\eta(W)$. In the latter case, we split the clow $W_{i}$ at the vertex $v$ to get a new clow $W_{i}^{\prime}$ and a simple cycle $C^{\prime}$. Then $\eta(W)$ is the clow sequence obtained by replacing $W_{i}$ by the new clow $W_{i}^{\prime}$ and inserting the cycle $C^{\prime}$ into the resulting clow sequence. The remaining clows in $W$ are kept untouched.

We note that the involution $\eta$ described above does not require that the clow sequence ${W}$ has exactly $n$ edges. In particular, $\eta(W)$ is well defined even when $W\in{\cal W}_{\mathfrak{G},k}$ for some graph $\mathfrak{G}$. Furthermore, for $W\in{\cal W}_{\mathfrak{G},k}$ we have $\eta(W)\in{\cal W}_{\mathfrak{G},k}$ and $\mathrm{sign}(W)=-\mathrm{sign}(\eta(W))$, since $\eta(W)$ has the same number of edges as $W$ and either has one clow more than $W$ or one clow less than $W$. Combining with the argument that $\eta$ is indeed an involution [37, Theorem 1], we conclude:

[TABLE]

Theorem 4.20.

The problem $p\mbox{-}\mathrm{det}$ for $(0,1)$-matrices can be written as a difference of two functions in $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$, and is $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}$-hard with respect to $\leq^{\mathrm{plog}}_{\mathrm{met}}$.

Proof A.17**.**

We prove this using a parameterised version of the algorithm given by Mahajan and Vinay [37, Thm. 2]. Let $A$ be the adjacency matrix of a directed graph $\mathfrak{G}$. We construct two $k$-bounded nondeterministic $\mathbf{para}\mathbf{L}$-machines $M_{1}$ and $M_{2}$ that have read-once access to their nondeterministic bits such that $p\mbox{-}\mathrm{det}(A,k)=\#\mathrm{acc}_{M_{1}}(A,k)-\#\mathrm{acc}_{M_{2}}(A,k).$

Both $M_{1}$ and $M_{2}$ behave exactly the same except for the last step, where their answer is flipped. More precisely, both machines nondeterministically guess a $k$-clow sequence, and $M_{1}$ accepts if the guessed clow sequence has a positive sign while $M_{2}$ accepts if the guessed clow sequence has a negative sign. Then, it follows from Lemma 4.19 that $p\mbox{-}\mathrm{det}(A,k)=\#\mathrm{acc}_{M_{1}}(A,k)-\#\mathrm{acc}_{M_{2}}(A,k).$

Now, we describe the process of guessing nondeterministic bits. The process is the same for both $M_{1}$ and $M_{2}$. We need the following variables throughout the process: curr-head, curr-vertex, parity, count, ccount. The variable curr-head contains the head of the clow currently being constructed, while parity holds the parity of the partial clow constructed so far and is initialised to $(-1)^{2n-k}$. Note that this initiation of parity is because we are going to compute sign of a clow sequence $W$ as $(-1)^{2n-k+r^{\prime}}$ where $r^{\prime}$ is the number of clows in $W$ with at least two edges. The variable count keeps track of the total number of edges used in the partial clow sequence constructed so far and ccount keeps track of the number of edges in the current $k$-clow. The machines $M_{1}$ and $M_{2}$ are described in Algorithm 2.

Note that the guess $a=0$ in step 5 leads to expansion of the current clow with addition of a newly guessed edge. The guess $a=1$ in step 5 leads to completion of the current clow by chosing the back edge to the head (step 10, only existence of such edge needs to be checked), and guessing head for a new clow. Since the parity of the number of clows changes for the case when $a=1$ we flip the parity (step 14). Note that the algorithm reaches step 17 if only if the nondeterministic choices correspond to a clow sequence with exactly $k$ edges. Hence, for $b\in\{1,2\}$ the machine $M_{b}$ accepts on all nondeterministic paths where the guessed $k$-clow sequence has parity $(-1)^{b+1}$ which completes the correctness proof.

Since both $M_{1}$ and $M_{2}$ guess exactly $k$ vertices, they are $k$-bounded. Also, only curr-vertex and curr-head need to be stored at any point of time, consequently the machines need only read-once access to nondeterministic bits. Finally, the machines use $O(\log|A|+\log k)$ space and are tail-deterministic, taking only $O(k\cdot\log|A|)$ steps after the first nondeterministic step.

For hardness we give a reduction from $\mathrm{p\text{-}}\#\mathrm{REACH}$. Let $\mathfrak{G},s,t$ be an instance of $\mathrm{p\text{-}}\#\mathrm{REACH}$, where $\mathfrak{G}$ is a DAG. Let $\mathfrak{G}^{\prime}$ be the graph obtained by adding the “back edge” $(t,s)$ to $\mathfrak{G}$. Note that the set of all $s$-$t$ paths in $\mathfrak{G}$ is in bijective correspondence with the set of cycles in $\mathfrak{G}^{\prime}$. Let $A^{\prime}$ be the adjacency matrix of $\mathfrak{G}^{\prime}$. Then $p\mbox{-}\mathrm{det}(A^{\prime},k)=(-1)^{2n-k+1}\cdot R$ where $R$ is the number of $s$-$t$ paths in $\mathfrak{G}$. As a result, $R$ can be retrieved from $p\mbox{-}\mathrm{det}(A^{\prime},k)$ in deterministic logspace. This completes the proof.

Appendix B Branching Programs

Preliminaries

A BP $P$ is a layered directed acyclic graph (DAG) with a source node $s$ and a sink node $t$ (see, e.g., textbook by Vollmer [48]). The vertices of the BP are labelled by input variables in $\{x_{1},\ldots,x_{n}\}$ and edges are labelled by [math] or $1$. An input $a_{1}\cdots a_{n}\in\{0,1\}^{n}$ is accepted by $P$ if there is a directed $s$ to $t$ path (short: $s$-$t$-path) $\rho$ that is consistent with $a$, that is, for each edge $(u,v)$ in $\rho$, ${{\mathbf{label}}}(u,v)=a_{i}$ where ${{\mathbf{label}}}(u)=x_{i}$. The BP $P$ is said to be deterministic (DBP for short) if every vertex has either no outgoing edge or exactly two outgoing edges, one labelled by [math] and the other by $1$. The size of the program $P$ is the number of vertices in it, the length is the length of a longest path starting from $s$. If $P$ has length $\ell$, then we assume that the vertices of $P$ are partitioned into layers $L_{0}\cup L_{1}\cup\ldots\cup L_{\ell}$ where $L_{0}$ contains the source and $L_{\ell}$ contains the sink. By layer $i$, we mean the set of vertices in $L_{i}$.

A family of branching programs is a family $\mathcal{P}=(P_{n})_{n\in\mathbb{N}}$ containing one BP $P_{n}$ for each input length $n\in\mathbb{N}$. In this article, every family of BPs is implicitly logspace-uniform (in the context of classical complexity) or $\mathbf{para}\mathbf{L}$-uniform (in the context of parameterised complexity). Details about notions of uniformity in the classical context can be found in the textbook of Vollmer [48]. We need a straightforward adaptation of these notions to the parameterised setting.

We let ${\mathbf{BP}}$ be the set of all languages accepted by polynomial-size families of BPs, and $\mathbf{DBP}$ be the set of all languages accepted by polynomial-size families of DBPs. Now, we will incorporate the notion of parameters to BPs. For that reason, the families of BPs are of the form $\mathcal{P}\mathrel{\mathop{:}}=(P_{n,m})_{n,m\geq 0}$. The language accepted by $\mathcal{P}$ is the set of all inputs $(x,k)\in\{0,1\}^{*}\times\mathbb{N}$ such that $P_{|x|,|k|}$ accepts $(x,k)$. Let ${\mathcal{C}}$ be a complexity class based on families of BPs of size $s(n)$. A family of $\mathbf{para}{\mathcal{C}}$-BPs is a family of BPs $(P_{n,m})_{n,m\geq 0}$ of size $s(n+f(m))$.

Note that, while the operator $\mathbf{para}$ is defined for arbitrary complexity classes, the operators ${\mathbf{para}}_{\mathbf{W}}$, and ${\mathbf{para}}_{\beta}$ are only defined with respect to TM based classes. These operators can be generalised to be also applicable to complexity classes based on BPs by extending the notion of $k$-bounded nondeterminism to this context, though. A family of branching programs with nondeterministic input has additional input bits that are marked as nondeterministic, similar to a choice tape for TMs. Let $\mathcal{P}\mathrel{\mathop{:}}=(P_{n,m})_{n,m\geq 0}$ be such a family and $\ell(n,m)$ be the number of nondeterministic input bits in $P_{n,m}$. Then $\mathcal{P}$ accepts an input $(x,k)\in\{0,1\}^{*}\times\mathbb{N}$, if there is a $y\in\{0,1\}^{\ell(|x|,|k|)}$ such that $P_{|x|,|k|}$ accepts $((x,k),y)$. Also, denote by $\#\mathrm{acc}_{P}(x,k)$ the number of $y\in\{0,1\}^{\ell(|x|,|k|)}$ such that $\mathcal{P}$ accepts $((x,k),y)$. While it might seem counter-intuitive at first, we also use the notion of deterministic families of BPs with nondeterministic input, meaning that the program is deterministic if the nondeterministic input is fixed. Furthermore, $\mathcal{P}$ is $k$-bounded if there exists a computable function $f$ such that for all $n,m\geq 0$, the number $\ell(n,m)\leq f(m)\cdot\log n$.

We will now introduce a notion of read-once access to nondeterministic bits for the above classes. This notion is inspired from the notion of read-once certificates considered in [5] and first defined in [36]. Let $P(x,y)$ be a BP with two inputs $x=x_{1}\cdots x_{n}$ and $y=y_{1}\cdots y_{m}$. Here, $y$ is the nondeterministic input. We say that $P$ is read-once certified if there are layers $i_{0}<i_{1}<i_{2}<\dots<i_{m}$ in the underlying graph of $P$ such that the variable $y_{j}$ occurs as a label only in layer numbers $\eta$ such that $i_{j-1}\leq\eta\leq i_{j}$.

Definition B.1**.**

Let ${\mathcal{C}}$ be the class of languages accepted by families of BPs of size $O(s(n))$ for some $s\colon\mathbb{N}\to\mathbb{N}$. Then, ${\mathbf{para}}_{\mathbf{W}}{\mathcal{C}}$ is the class of all parameterised languages computable by $k$-bounded families of $\mathbf{para}{\mathcal{C}}$-BPs.

Definition B.2**.**

Let ${\mathcal{C}}$ be the class of languages accepted by families of BPs of size $O(s(n))$ for some $s\colon\mathbb{N}\to\mathbb{N}$. Then, ${\mathbf{para}}_{\beta}{\mathcal{C}}$ is the class of all parameterised languages computable by $k$-bounded families of $\mathbf{para}{\mathcal{C}}$-BPs that are read-once certified.

Analogously, we also define the tail-nondeterministic variants of the operators ${\mathbf{para}}_{\mathbf{W}}$ and ${\mathbf{para}}_{\beta}$, called ${\mathbf{para}}_{{\mathbf{W}}[1]}$ and ${\mathbf{para}}_{\beta{\mathbf{tail}}}$, respectively.

Parameterised Counting and Branching Programs

Using the notion of bounded nondeterminism for the case of BPs, we define counting classes based on $\mathbf{DBP}$, which can be generalised to further classes of BPs.

Definition B.3**.**

Let $F$ be a parameterised function. Then, $F\in\#{\mathbf{para}}_{\mathbf{W}}\mathbf{DBP}$ if there exists a $k$-bounded family $\mathcal{P}=(P_{n,m})_{n,m\geq 0}$ of DBPs of size $O(f(k)\cdot p(|x|))$ such that for all $(x,k)$: $F(x,k)=\#\mathrm{acc}_{\mathcal{P}}(x,k)$. We say that $F$ is also in

• •

$\#{\mathbf{para}}_{\beta}\mathbf{DBP}$* if there is such a $\mathcal{P}$ that is read-once certified,*

• •

$\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{DBP}$* if there is such a $\mathcal{P}$ that is tail-nondeterministic, and*

• •

$\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{DBP}$* if there is such a $\mathcal{P}$ that is read-once certified and tail-nondeterministic.*

$\mathbf{NL}$ coincides with the class of all languages accepted by logspace-uniform families of BPs of polynomial size [39]. The desired family of BPs is obtained from the configuration graph of a nondeterministic logspace-bounded machine preserving the number of accepting paths, and hence the result generalises to the corresponding counting classes. We extend these relationships to the parameterised setting. We need the following construction based on configuration graphs.

Lemma B.4**.**

Let $M$ be a $k$-bounded nondeterministic \mathbf{para}$$\mathbf{L}-machine. Then for any input $(x,k)$ there is a layered DAG $\mathfrak{G}_{M,n,m}$ with two special vertices $s$ and $t$ such that $\#\mathrm{acc}_{M}(x,k)$ is the number of paths from $s$ to $t$ in $\mathfrak{G}_{M,n,m}$. Given $M$ and $(x,k)$, the graph $\mathfrak{G}_{M,n,m}$ can be computed in $\mathbf{para}\mathbf{L}$.

Proof B.5**.**

In general, the configuration graph of a nondeterministic space-bounded machine is not layered and layering an arbitrary DAG might require reachability which is not possible in logspace-uniform fashion. However, we can modify the machine by adding a step counter, resulting in a layered configuration graph. We explain the details of this modification below.

Let $M$ be a $k$-bounded, $s$ space-bounded TM. Without loss of generality, $M$ has a unique accepting configuration. We now construct the machine $\widehat{M}$ modifying $M$ as follows: In addition to the tapes of $M$, $\widehat{M}$ has an extra tape that keeps a binary step counter for $M$. The machine $\widehat{M}$ simulates $M$ step by step and after each step of $M$, it increments the counter by one. By construction, $\widehat{M}$ behaves exactly as $M$ apart from the additional counter. Note that at most $O(s)$ bits are required to store the counter because the runtime of $M$ is bounded by $2^{O(s)}$. For a given input $x$, a configuration of $\widehat{M}$ on $x$ can be represented as $(\gamma,i)$ where $\gamma$ is a configuration of $M$ on the input $x$, and $i$ is the content of the additional tape of $\widehat{M}$ that contains the binary counter. To simplify things, we assume that $i$ is a number in $\{0,\ldots,2^{O(s)}\}$, ignoring the head position information on the tape used for storing the counter. The normalised configuration graph of $\widehat{M}$ is a graph on the set of all possible configurations of $\widehat{M}$ on any input of length $n$, with the edge relations as follows. There is an edge from configuration $(\gamma,i)$ to $(\gamma^{\prime},i^{\prime})$ if and only if $\gamma^{\prime}$ is reachable from $\gamma$ in a single step of $M$ and $i^{\prime}=i+1$. That is, the steps required to update the counter are merged into the preceding step of $M$ in the normalised configuration graph.

The generic configuration graph $\mathfrak{G}_{M,n,m}$ of $\widehat{M}$ on inputs $(x,k)$ with $x=x_{1}\cdots x_{n}$ and $m=|k|$ is defined as follows: The set of vertices is the set of all configurations $(\gamma,i)$ of $\widehat{M}$ on any input of length $n,m$ without information on the content of the input tape. Additionally, vertices are labelled with variables $\{x_{1},\dots,x_{n},k_{1},\dots,k_{m}\}$ and edges are labelled from $\{0,1\}$ in the same way as for BPs: Vertex labels state which input bit is read in the next step of the computation while edge labels state for which value of the respective input bit that edge is used. It is not hard to see that the underlying graph of any generic configuration graph for input lengths $n,m\geq 0$ is a layered DAG. Moreover, it can be seen that for any $(x,k)\in\{0,1\}^{*}\times\mathbb{N}$, $M$ accepts $(x,k)$ if and only if there is a directed path from the initial configuration to the accepting configuration in $G_{M,|x|,|k|}$ such that the edge labels along the path are consistent with the bits of $x$ and $k$. Finally, we may note that there is a $\mathbf{para}\mathbf{L}$-machine $N$ that, given $(C,i)$ and $(C^{\prime},i^{\prime})$, decides if $G_{M}$ has an edge from $(C,i)$ to $(C^{\prime},i^{\prime})$. Accordingly, the construction of $\mathfrak{G}_{M,n,m}$ is $\mathbf{para}\mathbf{L}$-uniform.

Theorem B.6**.**

For any $o\in\{\mathbf{W},\mathbf{W}[1],\beta,\beta\mbox{-}\mathbf{tail}\}$, we have that $\#\mathbf{para}_{o}\mbox{-}\mathbf{DBP}=\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$.

Proof B.7**.**

We will first show that $\#\mathbf{para}_{o}\mbox{-}\mathbf{DBP}\subseteq\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$ for $o$ as above, giving the detailed argument for $o=W$ and outlining the changes required (if any) for the remaining cases.

Let $F\in\#{\mathbf{para}}_{\mathbf{W}}\mathbf{DBP}$ via the $\mathbf{para}\mathbf{L}$-uniform family $\mathcal{P}\mathrel{\mathop{:}}=(P_{n,m})_{n,m\geq 0}$ of BPs of size $g(m)\cdot n^{c}$ for $c\in\mathbb{N}$. Let $M$ be a $k$-bounded NTM $M$ which on input $(x,k)$ evaluates $P_{|x|,k}$ on that input, such that every $s$-$t$-path in $P_{|x|,k}$ corresponds to a unique accepting path of $M$. Algorithm 3 describes the behaviour of a machine with these properties. Since $\mathcal{P}$ is $\mathbf{para}\mathbf{L}$-uniform, there is a $\mathbf{para}\mathbf{L}$-machine $M^{\prime}$ that on input $(1^{n},k)$ outputs $P_{n,k}$ as a graph. Since $M$ cannot store $P_{|x|,k}$, as usual with composition of space-bounded algorithms, whenever $M$ needs to access an edge of $P_{|x|,k}$, $M$ runs the machine $M^{\prime}$ from the start until the required edge is output or $M^{\prime}$ halts, in which case the required edge is treated as absent in $P_{|x|,k}$.

By construction $\#\mathrm{acc}_{M}(x,k)=\#\mathrm{acc}_{P}(x,k)$ for all $(x,k)\in\{0,1\}^{*}\times\mathbb{N}$. Furthermore, $M$ is $h(k)\cdot|x|^{O(1)}$ space-bounded for some computable $h$, since it only needs to store two vertices of $P_{|x|,k}$ as well as the space needed to construct $P_{|x|,k}$. The machine is $k$-bounded, because $\mathcal{P}$ is $k$-bounded. This concludes the proof for $o=W$. If $P_{n,m}$ is read-once certified for all $n,m$, then $M$ requires only a read-once access to nondeterministic bits. If $P_{n,m}$ is tail-nondeterministic, so is $M$.

Now, we prove $\#\mathbf{para}_{o}\mbox{-}\mathbf{DBP}\supseteq\#\mathbf{para}_{o}\mbox{-}\mathbf{L}$ for $o$ as in the statement of the theorem. Our argument crucially uses the fact that the generic configuration graph $\mathfrak{G}_{M,n,m}$ of a $k$-bounded machine is layered and can be constructed in $\mathbf{para}\mathbf{L}$ on input $(x,k)$ with $|x|=n,|k|=m$ (Lemma B.4). As in the case of $``\subseteq$”, we argue for the case of $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ and mention the modifications required (if any) for the remaining classes. Let $F\in\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}$ via the $k$-bounded machine $M$ using $O(\log n+g(k))$ space on all inputs $(x,k)$. Without loss of generality, we assume that the machine $M$ reads either from the input tape or from the choice tape in any configuration. Let $P_{n,m}\mathrel{\mathop{:}}=\mathfrak{G}_{M,n,m}$ be the generic configuration graph of $M$ for input length $n$ and $m=|k|$. Then, $M$ accepts $(x,k)$ if and only if there is an assignment $y\mathrel{\mathop{:}}=y_{1},\ldots,y_{\ell}\in\{0,1\}$ to the nondeterministic input such that $P_{n,m}$ has a directed path consistent with the input $((x,k),y)$ from the initial configuration to the accepting configuration. In fact, there is a $1$-to-$1$-correspondence between accepting computation paths of $M$ and choices for $y$. As a result, $\#\mathrm{acc}_{P}(x,k)=\#\mathrm{acc}_{M}(x,k)$ as required. Also, $P_{n,m}=\mathfrak{G}_{M,n,m}$ can be constructed using a $\mathbf{para}\mathbf{L}$ uniformity machine. This shows that $\#{\mathbf{para}}_{\mathbf{W}}\mathbf{L}\subseteq\#{\mathbf{para}}_{\mathbf{W}}\mathbf{DBP}$.

For the case of ${\mathbf{para}}_{\beta}\mathbf{L}$, we need to show that the resulting DBP $P_{n,m}$ is read-once certified. However, it may happen that the configuration $(C,i)$ reads variable $y_{j}$, whereas $(C^{\prime},i)$ reads variable $y_{j^{\prime}}$ with $j\neq j^{\prime}$. This makes $P_{n,m}$ far from being read-once certified. However, a crucial observation is that in any start-to-terminal path in $P_{n,m}$, the $y$-variables are read in the order $y_{1},\ldots,y_{\ell}$, and if $y_{j}$ is read at any point, then none of the $y_{i}$’s for $i<j$ will be read along this path after this point. Accordingly, with suitable staggering we can make $P_{n,m}$ read-once certified. We sketch the process below.

For $1\leq i\leq m$, let $i_{\alpha}$ be the largest number such that there is a configuration $C$ such that $(C,i_{\alpha})$ reads the nondeterministic bit $y_{i}$. We delay the computations so that the last read of $y_{i}$ occurs until layer $i_{\alpha}$ and the variable $y_{i+1}$ is read only after layer $i_{\alpha}$. That is, for $y_{1}$, we wait till layer number $1_{\alpha}$ before proceeding to read $y_{2}$, and for $y_{2}$ we wait till layer $2_{\alpha}$ before proceeding to read $y_{3}$ and so on. This can be achieved by adding necessary dummy nodes that have a single outgoing edge labelled by $1$. For the whole process we only need the value of $i_{\alpha}$ which can be computed in $\mathbf{para}\mathbf{L}$ given access to the uniformity machine. Consequently, the overall staggering process can be done in $\mathbf{para}\mathbf{L}$ so that the resulting BP is uniform. It may be noted that we do not alter the number of accepting paths during the above process.

From the above, we conclude that $\#{\mathbf{para}}_{\beta}\mathbf{L}\subseteq\#{\mathbf{para}}_{\beta}\mathbf{DBP}$. Finally, in the case of tail-nondeterminism, we may note that if $M$ is tail-nondeterministic then so is $\mathfrak{G}_{M,n,m}$ for every input length $n$. Since the above staggering process does not alter tail-nondeterminism, we conclude that $\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{L}\subseteq\#{\mathbf{para}}_{{\mathbf{W}}[1]}\mathbf{DBP}$ and $\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{L}\subseteq\#{\mathbf{para}}_{\beta{\mathbf{tail}}}\mathbf{DBP}$.

Theorem B.8**.**

For any $o\in\{\mathbf{W},\mathbf{W}[1],\beta,\beta\mbox{-}\mathbf{tail}\}$, we have that $\#\mathbf{para}_{o}\mbox{-}\mathbf{BP}=\#\mathbf{para}_{o}\mbox{-}\mathbf{NL}$.

Proof B.9** (Proof Idea.).**

In the proof of Theorem B.6, for the graph $P_{n,m}=\mathfrak{G}_{M,n,m}$, the properties such as $k$-bounded nondeterminism, read-once certified nondeterministic bits and tail-nondeterminism are preserved only in the component reachable from the initial configuration. The remaining part of the BP may not have these properties but is not relevant to the program.