\section{Introduction}
We consider the task of identifying fixed-parameter tractable (FPT) problems that admit space-efficient algorithms. Towards this end, we devise algorithms for various parameterized problems that run in time $f(k)\, n^{\Oh{1}}$ and use either $g(k) + \log{n}$ or $g(k) \log{n}$ bits of space, where $n$ denotes the input size, $k$ denotes the parameter, and $f, g: \N \to \N$ are computable functions.

\subsubsection{Previous Work} Work on restricted-space classes of parameterized problems was initiated by Cai et al.~\cite{CCDF1997AnnPureApplLogic}, who defined the classes $\cLAdv$ and $\cSlL$, which we call $\cParaL$ and $\cXL$ respectively. Among other things, they showed that $\pVC$ under the usual solution-size parameterization is in $\cParaL$. Continuing this line of work, Flum and Grohe~\cite{FG2003InfComput} showed that the parameterized model-checking problem of first-order formulas on graphs of bounded degree is in $\cParaL$. As a consequence, many standard parameterized graph problems are in $\cParaL$ when restricted to bounded-degree graphs. Then, Elberfeld et al.~\cite{EST2012IPEC} introduced two new restricted-space classes and gave completeness results for those classes, showing that there are problems fixed-parameter tractable (FPT) problems which are outside $\cParaL$ under the assumption that $\cL{} \neq \cNL$. In particular, they identified $\pDFVS$ as one such problem. In contrast, $\pDFVS$ restricted to tournaments can be shown to be in $\cParaL$ (Corollary~\ref{corr:del_dhs}). Later work in this setting includes the paper of Chen and M\"{u}ller~\cite{CM2015TOCT}, who studied additional complexity-theoretic aspects of restricted-space classes and showed that $\pLongPath$ is in $\cParaL$.

$\pdHS$, a generalization of $\pVC$ to hypergraphs was shown by Fafanie and Kratsch~\cite{FK2015MFCS} to be kernelizable in logarithmic space, which puts it in $\cParaL$ (see Lemma~\ref{lemm:para-l_kern}). As a consequence they showed that various graph deletion problems where the target classes are characterized by finite forbidden sets are also in $\cParaL$. For related results, see~\cite{BT2020TheoryComputSyst,BST2020SWAT} which give constant-time parallel kernelization algorithms for $\pHS$.

\subsubsection{Results, Techniques and Organization} Section~\ref{sect:deletion} begins by showing that $\pHS$ (with possibly unbounded set sizes) can be placed in $\cParaL$ under the restriction that pairwise intersections of sets in the instances have bounded sizes.

Then in Section~\ref{sect:deletion_problems}, we extend the results of Fafianie and Kratsch~\cite{FK2015MFCS} by showing that some graph deletion problems where the target classes have infinite forbidden sets are also in $\cParaL$.
As applications, we show that $\pDLF$ and $\pDPo$ are in $\cParaL$.

Initially, studies in parameterized complexity concerned the solution-size parameter or width parameters such as treewidth and cliquewidth. In recent times, vertex cover number as a parameter has become a subject of serious investigation~\cite{Jan2013thesis,FJP2014JCSS,Jd2020SWAT}. In Section~\ref{sect:vc_parameterization} we give $\cParaL$ algorithms for problem parameterized by vertex cover number. We devise a logarithmic-space variant of a general kernelization algorithm~\cite{FJP2014JCSS} for problems parameterized by vertex cover number, and as a consequence obtain $\cParaL$ algorithms for $\pFVS$, $\pOCT$, $\pChVD$, $\pPlan$, $\pLongPath$, $\pLongCycle$ and $\pdCol$ under this parameterization.

Finally, in Section~\ref{sect:fvs}, we address problems that are not known to be in $\cParaL$, but are known to be in $\cFPT$ as well as in $\cXL$, i.e.\ solvable using $f(k) + \Oh{\log n}$ bits of space. We ask whether there are algorithms for those problems that \emph{simultaneously} run in time $f(k)\, n^{\Oh{1}}$ and in $f(k) \log{n}$ bits of space. Towards this end, we devise such an algorithm for $\pFVS$. This is achieved via a careful space-efficient implementation of the iterative-compression algorithm of Chen et al.~\cite{CFL+2008JCSS}.

 \section{Preliminaries}
\subsubsection{Notation and Definitions}
For a graph $G$, we denote its vertex set by $V(G)$ and edge set by $E(G)$.
A class of graphs $\Pi$ is said to be \emph{characterized} by a set $\Phi$ of induced subgraphs if $\Pi$ consists of precisely those graphs that do not include induced subgraphs isomorphic to any graph in $\Phi$.

\subsubsection{Appendix} Details for all items marked $\dagger$ can be found in the Appendix.

\subsubsection{Parameterized Problems and Space Classes}
Let $A$ be a decision problem over the alphabet $\Sigma$ and $t: \Sigma^* \to \N$ be a computable function. The pair $(A, t)$ is called a \emph{parameterized} problem and $t$ is called the \emph{parameterization}.

An instance of the problem is a pair $(I, t(I))$, where $I$ is an instance of $A$. The problem $(A, t)$ is said to be \emph{fixed-parameter tractable} (FPT) if there is an algorithm which solves any instance $(I, t(I))$ in time $f(t(I)) {\abs{I}}^c$, where $f: \N \to \N$ is a computable function, $n = \abs{I}$, and $c > 0$ is a constant. Later on, we refer to such running times as \emph{FPT time}.

The problem is \emph{kernelizable} if there is an algorithm which in time polynomial in $n$ computes an instance $I'$ such that $\abs{I'} = g(t(I))$ for some computable function $g: \N \to \N$ and $I$ is a \YES{} instance if and only if $I'$ is a \YES{} instance. The instance $I'$ is called a \emph{kernel}. Kernels are obtained through what are called \emph{reduction rules}, which transform a given instance into another. And the rule is \emph{safe} if the two instances are equivalent.

In this paper, we focus on the \emph{space complexity} aspect of parameterized problems. A natural problem class to consider in this setting is $\cParaL$, defined below.

\begin{definition}[$\cParaL$; Cai et al.~\cite{CCDF1997AnnPureApplLogic}]
	$\cParaL$ is the class of all parameterized problems $(A, t)$ for which there is a deterministic algorithm which solves instances $(I, t(I))$ using space $f(k) + \Oh{\log{n}}$, where $f: \N \to \N$ is a computable function, $k = t(I)$ and $n = \abs{I}$.
\end{definition}

We also consider an analogous class $\cXL$, where the space bound is $f(k) \cdot \log{n}$ instead of $f(k) + \Oh{\log{n}}$. The two classes are known to be distinct unless $\cP{} = \cL$ (Theorem 3.1 of~\cite{CCDF1997AnnPureApplLogic}).
\begin{definition}[$\cXL$; Cai et al.~\cite{CCDF1997AnnPureApplLogic}]
	$\cXL$ is the class of all parameterized problems $(A, t)$ for which there is a deterministic algorithm which solves instances $(I, t(I))$ using space $f(k) \cdot \log{n}$, where $f: \N \to \N$ is a computable function, $k = t(I)$ and $n = \abs{I}$.
\end{definition}

\subsubsection{Machine Model}
We use the standard model for space-efficient algorithms. The input to an algorithm resides in read-only memory and can be randomly accessed, while the output is written to a stream which cannot be read from. The algorithm uses a small number of read-write cells as auxiliary memory, where each cell can hold a word of size $\Oh{\log{n}}$ bits ($n$ is the input size). The machine is a unit-cost RAM in which basic arithmetic and logic operations involving two words take constant time.

A basic result in parameterized complexity theory is that a problem is fixed-parameter tractable if and only if it is kernelizable. The following lemma is an easy consequence of the result.
\begin{lemma}\label{naivespace}
If a parameterized problem is fixed-parameter tractable, then it can be solved using $f(k) + n^{O(1)}$ space where $f$ is some function of the parameter $k$, and $n$ is the input size.
\end{lemma}

The next result is implicit in~\cite{CCDF1997AnnPureApplLogic}; we include it here for the sake of clarity.
\begin{lemma}\label{lemm:para-l_kern}\exS{$\dagger$}
	Let $(A, t)$ be a parameterized problem. For any computable function $f: \N \to \N$, the following statements are true.
	\begin{itemize}
		\item If $(A, t)$ can be solved in space $f(k) + \Oh{\log{n}}$, then it can be kernelized in space $\Oh{\log{n}}$.
		\item If $(A, t)$ can be kernelized in space $f(k) + \Oh{\log{n}}$, then it can be solved in space $g(k) + \Oh{\log{n}}$, where $g: \N \to \N$ is a computable function.
	\end{itemize}
\end{lemma}

 \section{Hitting Set and Graph Deletion Problems}\label{sect:deletion}
We begin by examining two known small-space kernelization results. The first is a combination a logarithmic-space implementation of the Buss rule~\cite{BG1993SICOMP} for $\pVC$ and the observation that the kernel produced is itself a vertex cover.

\begin{proposition}[Cai et al.~\cite{CCDF1997AnnPureApplLogic}, Theorem 2.3]\label{prop:vc_para-l}
	There is an algorithm which takes as input a graph $G$ and $k \in \N$, and using space $\Oh{\log n}$, either answers correctly that $G$ has no vertex cover of size at most $k$ or produces a vertex cover of size at most $2k^2$.
\end{proposition}

The next result gives an equivalent algorithm for $\pdHS$.
\begin{proposition}[Fafianie and Kratsch~\cite{FK2015MFCS}, Theorem 1]\label{prop:dhs_log_kern}
	There is an algorithm which takes as input an instance of $\pdHS$, i.e. a universe $U$, a family $\mathcal{F}$ of subsets of $U$ of size $d$ each and an integer $k$, and in time $n^{\Oh{d^2}}$ and $\Oh{d^2 \log{n}}$ bits of space, either answers correctly that the instance has no hitting set of size at most $k$ or produces an instance $(U', \mathcal{F}', k)$ such that
	\begin{itemize}
	 	\item $U' \subseteq U,\ \abs{U'} \leq d{(k + 1)}^d$,
	 	\item $\mathcal{F}' \subseteq \mathcal{F},\ \abs{\mathcal{F}'} \leq {(k + 1)}^d$, and
	 	\item for all $S \subseteq U$ with $\abs{S} \leq k$, $S\ \text{is a minimal hitting set for}\ \mathcal{F}$ if and only if $S\ \text{is a minimal hitting set for}\ \mathcal{F}'$.
	 \end{itemize}
\end{proposition}

Since the above algorithm kernelizes $\pdHS$ in logarithmic space (for constant $d$), we have the following result as a consequence of Lemma~\ref{lemm:para-l_kern}.

\begin{corollary}\label{corr:dhs_para-l}
	For constant $d$, $\pdHS$ is in $\cParaL$.
\end{corollary}

\subsection{Deletion Problems}\label{sect:deletion_problems}
We begin this section by showing that if a certain restriction of a general graph deletion problem ($\pDelPi$, defined below) is in $\cParaL$, then the entire problem is in $\cParaL$. Combining this with a method for partially encoding these problems as $\pHS$, we show that $\pDLF$ and $\pDPo$ are in $\cParaL$. The problem $\pDelPi$ has the following form.

\textbf{Instance:} $(G, k)$, where $G$ is a graph and $k \in \N$\\
\hspace*{\parindent}\textbf{Question:} Is there a set $S \subseteq V$ with $\abs{S} \leq k$ such that $G - S \in \Pi$?\\

When $\Pi$ is characterized by a finite set of forbidden induced subgraphs $\Phi$, instances of $\pDelPi$ can be modelled as $\pdHS$. As an example, consider $\pCVD$, where the objective is to delete up to $k$ vertices in an input graph such that the resulting graph is a cluster graph. The class of cluster graphs is exactly the class of graphs which do not have a path on three vertices $P_3$ as induced subgraphs. Because of this, an instance $(G, k)$ of the problem can be encoded as an instance $(U, \mathcal{F}, k)$ of $3$--$\pHS$, where $U = \V{G}$ and $\mathcal{F} = \setb{\V{P}}{P\ \text{is an induced}\ P_3\ \text{in}\ G}$. The family of sets $\mathcal{F}$ is can be generated in logarithmic space: enumerate all subsets of $\V{G}$ of size $3$ and output those that induce a $P_3$. t is easy to see that $(U, \mathcal{F}, k)$ is a \YES{} instance of $3$--$\pHS$ if and only if $(G, k)$ is a \YES{} instance of $\pCVD$. This family can now be used as input to a $3$--$\pHS$ algorithm, and because of Corollary~\ref{corr:dhs_para-l}, the instance can be solved in $f(k) + \log{n}$ bits of space. A variety of other problems can be solved in a similar fashion, leading to the following result.

\begin{corollary}\label{corr:del_dhs}
	$\pCVD$, $\pDFVS$ restricted to tournaments, $\pSVD$ and $\pThVD$ are in $\cParaL$.
\end{corollary}

In what follows, we describe the main result of this section, which extends Corollary~\ref{corr:del_dhs} to also include some variants of $\pDelPi$ where $\Pi$ is characterized by an infinite set of forbidden induced subgraphs.

\begin{theorem}\label{thm:restr_para_l}\exS{$\dagger$}
	Let $\Psi \supseteq \Pi$ be a class of graphs and let $\prob{ResDel\textPi}$ be the restriction of $\pDelPi$ to graphs in $\Psi$. If $\Psi$ is characterized by a finite set $\Phi$ of forbidden induced subgraphs and $\prob{ResDel\textPi} \in \cParaL$, then $\pDelPi \in \cParaL$.
\end{theorem}

Since $\pDelPi$ restricted to $\Psi$ is in $\cParaL$, there is an algorithm which solves restricted instances $(H, k)$ of $\pDelPi$ using space $f(k) + \Oh{\log{n}}$ ($f: \N \to \N$, a computable function). Let \algo{SolveDel\textPi{}On\textPsi{}} be such an algorithm. Using this as a subroutine, Algorithm~\ref{algo:SolveDelPi} solves $\pDelPi$.

\begin{algorithm}[h]
\KwIn{$(G, k)$, where $G$ is a graph and $k \in \N$}
\KwOut{\YES{} if there is a set $S \subseteq V$ of size at most $k$ such that $G - S \in \Pi$, and \NO{} otherwise}

	let $c_1, \dotsc, c_t$ be the sizes of the sets in $\Phi$\;
	$d \gets \max \brc{c_1, \dotsc, c_t},\ V \gets \V{G}$\;
	$\mathcal{F} \gets \setb{S \subseteq V}{G[S]\ \text{is isomorphic to some}\ H \in \Phi}$\;
	$(V', \mathcal{F}', k) \gets \algoi{KernelizeDeeHS}{d, V, \mathcal{F}, k}$\;
	\Return{\algoi{BranchAndCall}{$G, \mathcal{F}', \emptyset, k$}}\;
	\SetKwFunction{bncproc}{BranchAndCall}
  \SetKwProg{subproc}{Procedure}{}{}
  \subproc{\bncproc{$G, \mathcal{F}', S, l$}}{
  	\If{$l < 0$}{
  		\Return{\NO{}}\;
  	}
  	\eIf(\tcp*[f]{$G - S$ is in $\Psi$}){$S$ hits all of $\mathcal{F}'$}{
  		\If{\algoi{SolveDel\textPi{}On\textPsi{}}{$G - S, l$} returns \YES{}}{
  			\Return{\YES{}}\;
			}
  	}{
  		find a set $A \in \mathcal{F}'$ such that $A \cap S = \emptyset$\;
  		\For{$v \in A$}{
  			\If{\algoi{BranchAndCall}{$G, \mathcal{F}', S \cup \brc{v}, l - 1$} returns \YES{}}{
  				\Return{\YES{}}\;
  			}
  		}
  	}
  	\Return{\NO{}}\;
  }

\caption{SolveDel\textPi: solve \pDelPi{} with access to \algo{KernelizeDeeHS}, which kernelizes \pdHS{}, and \algo{SolveDel\textPi{}on\textPsi{}}, which solves the restriction of \pDelPi{} to \textPsi{}}\label{algo:SolveDelPi}
\end{algorithm}

\begin{lemma}\label{lem:correctness}\exS{$\dagger$}
	Algorithm~\ref{algo:SolveDelPi} solves $\pDelPi$ in $g(k) + \Oh{\log{n}}$ bits of space ($g: \N \to \N$, a computable function).
\end{lemma}

The claim of Theorem~\ref{thm:restr_para_l} now readily follows from the preceding discussion. The next result is an application of Theorem~\ref{thm:restr_para_l} which makes use of \algo{SolveDel\textPi{}On\textPsi{}} routines for some specific graph classes $\Psi$. It is pertinent here to note that the target classes $\Pi$ do not have characterizations by finite forbidden sets.

\begin{corollary}\label{corr:dlf_pw1}\exS{$\dagger$}
	\pDLF{}  and \pDPo{} are in $\cParaL$.
\end{corollary}

Both problems are related to $\pFVS$ (delete vertices so that the resulting graph is a forest): a solution to either problem is also a feedback vertex set. While we are able to show that \pDLF{} and \pDPo{} are in \cParaL{}, the known kernelization algorithms and fixed-parameter algorithms for $\pFVS$ (where the parameter, i.e.\ the solution size, is smaller) use strategies which appear difficult to carry out in the $\cParaL$ setting.

\subsection{$\pHS$ with Bounded Intersection}
Proposition~\ref{prop:dhs_log_kern} shows that one can, in logarithmic space, compute kernels for instances of $\pdHS$ in which each set is of size $d$. In this section, we obtain a similar result for the scenario where not the set sizes, but the intersection between any pair of sets is bounded by a constant $s$. Interestingly, the kernelization question for this natural $\pHS$ variant has not been addressed in earlier works, even with no constraints on space.

\subsection*{Case $s = 1$}
We first consider the case $s = 1$, i.e.\ when the instances are linear hypergraphs~\cite{Ber1989book}. Let $(U, \mathcal{F}, k)$ be an instance of $\pHS$ where the intersection between any pair of sets is of size at most $s = 1$. The algorithm consists of the following sequence of reduction rules.

\begin{description}
	\item[Rule $1$] Let $S$ be the set of all elements that appear in at least $k + 1$ sets in $\mathcal{F}$. If $\abs{S} > k$, return \NO{}. Otherwise, delete all sets in $\mathcal{F}$ that intersect with $S$ and delete all elements of $S$ from $U$. Set $k \gets k - \abs{S}$.

	\item[Rule $2$] If the number of sets remaining is more than $k^2$, then return NO.

	\item[Rule $3$] For each remaining set, determine the elements that appear in no other set. Delete all but one of them from the set and from the universe.
\end{description}

The following lemma establishes the correctness of the above rules and gives a bound on the size of the final instance.
\begin{lemma}\label{lemm:hs_corr}\exS{$\dagger$}
	Reduction Rules $1$, $2$ and $3$ produce a kernel $(U', \mathcal{F}', k')$, where $\abs{U'} \leq k^2$ and $\abs{\mathcal{F}'} \leq k^4$.
\end{lemma}

\subsubsection{Space-Efficient Implementation}
Reduction Rule $1$ can be implemented using two counters in addition to a constant number of counters for iteration. The first counter counts, for each element, the number of sets it appears in. The second counter counts the number of elements for which the first counter is larger than $k$. If the second counter goes beyond $k$, we return \NO{}. Otherwise, we set $k \gets k - k'$, where $k'$ is the value of the second counter.

To implement Reduction Rule $2$, we set up two additional counters and run through all the sets. The first counter checks for each set whether there is any element in it that appears more than $k$ times in $\mathcal{F}$. If no element of the set appears in more than $k$ times, then the set survives after Reduction Rule $1$, and we increment the second counter. Once all sets have been processed in this manner, if the value of the second counter is more than $k^2$, we return \NO{}.

To implement Reduction Rule $3$, we first determine as for Rule $2$ which sets $S$ survive the application of Rule $1$. We suppress the sets that do not survive, and output a subset of $S$ as follows. Observe that at this point, elements in each surviving set appear at most $k$ times in the entire instance. For each element of $S$, we count the number of times it appears in the instance. We output all elements that appear more than once, and of the ones that appear exactly once, we output the first such element in the set. The latter step can be performed using the following rule for each element $x$ in $S$ that appears exactly once in the instance: output $x$ only if there is no other element in $S$ before $x$ which also appears exactly once in the instance. This only uses a constant number of additional counters.

Observe that in all the steps above, only a constant number of additional counters are used, from which it readily follows that the entire procedure uses $\Oh{\log{n}}$ bits of space. Combining this with Lemma~\ref{lem:correctness}, we have the following result.

\begin{theorem}
    Given a number $k \in \N$ and a family of sets from a finite universe of size $n$ where each pair of sets intersect in at most one element, using $\Oh{\log{n}}$ bits of space, one can either determine that the given instance is a \NO{} instance of $\pHS$ or output an equivalent instance consisting of a family of at most $k^2$ sets with at most $k^2$ elements each such that each pair of sets intersects in at most one element.
\end{theorem}

Combining the above result with Lemma~\ref{lemm:para-l_kern}, we have the following corollary.
\begin{corollary}
	$\pHS$ restricted to instances where any pair of sets intersect in at most one element is in $\cParaL$.
\end{corollary}

\subsection{Case $s > 1$}\label{ssct:bd_hs_dg1}
In this case, the instance can be reduced using similar rules as before, with a sequence of $s - 1$ rules replacing Reduction Rule $1$ in the $s = 1$ case.

\begin{description}
	\item[Rule $i$ ($i = 1, \dotsc, s - 1$)] If there is an $(s+1-i)$-element subset of the universe that appears as a subset of $k^i+1$ sets, then replace all those sets with just the $(s+1-i)$-element set.

	For example, Reduction Rule $1$ ensures that if an $s$-element subset of the universe appears in $k+1$ sets, then all those sets are replaced with just the common $s$-element subset.

	\item[Rule $s$] Let $S$ be the set of all elements that appear in at least $k^s + 1$ sets in $\mathcal{F}$. If $\abs{S} > k$, return \NO{}. Otherwise, delete all sets in $\mathcal{F}$ that intersect with $S$ and delete all elements of $S$ from $U$. Set $k \gets k - \abs{S}$.

	\item[Rule $(s+1)$] If the number of sets remaining is more than $k^{s + 1} + 1$, then return \NO{}.

	\item[Rule $(s+2)$] For each remaining set, determine the elements that appear in no other set. Delete all but one of them from the set and from the universe.
\end{description}

As in the $s = 1$ case, the above rules ensure that the size of the final instance is bounded by a function of $k$. In addition, the rules can be applied using $\Oh{s \log{n}}$ bits of space per rule. Owing to space constraints, we defer the space-efficient implementation of the above rules to Appendix~\ref{apdx:deletion} and state our result directly.

\begin{theorem}\exS{$\dagger$}
    Given a family of sets from an $n$-element universe where each pair of sets intersects in at most $s$ elements, using $\Oh{s^2 \log{n}}$ bits of space, one can either determine that the given instance is a \NO{} instance of $\pHS$ or output an equivalent family of at most $k^{s + 1}$ sets with at most $s k^{s + 1}$ elements each such that each pair of sets intersects in at most $s$ elements.
\end{theorem}

Combining the above result with Lemma~\ref{lemm:para-l_kern} yields the following corollary.

\begin{corollary}
	For constant $s$, $\pHS$ restricted to instances where any pair of sets intersect in at most $s$ elements is in $\cParaL$.
\end{corollary} \section{Vertex Cover Number as Parameter}\label{sect:vc_parameterization}
With respect to the standard parameter (solution size), problems such as $\pTW$ and $\pFVS$ are not known to be in $\cParaL$. In this section, we show that when parameterized by vertex cover number, these problems are in fact in $\cParaL$.

Elberfeld et al.~\cite{EJT2010FOCS} give an algorithm for computing the treewidth of an undirected graph using space $f(k) \cdot \log{n}$, which puts the problem in $\cXL$, but it is not known if the problem is in $\cParaL$. For $\pFVS$, the obvious ``guess and verify'' algorithm puts it in $\cXL$, but does not run in FPT time. The known fixed-parameter algorithms for these problems (see e.g.~\cite{CFL+2008JCSS,RSS2006TALG}) involve complex branching strategies and it seems unlikely that they can be carried out using space $f(k) + \Oh{\log{n}}$.

The following definition captures classes of graphs which are closed under  certain modification operations. Such graph classes encompass ``target'' graphs for many graph modification and partitioning problems, and can be used to show the kernelizability of these problems, as shown later.

\begin{definition}[Bounded-Adjacency Characterization; Fomin et al.~\cite{FJP2014JCSS}]
	Let $\Pi$ be a class of graphs and $c_{\Pi} \in \N$ be a constant. If for any graph $G \in \Pi$ and any vertex $v \in \V{G}$, there is a set of vertices $D \subseteq \V{G} \setminus \brc{v}$ with $\abs{D} \leq c_{\Pi}$ such that adding or removing any number of edges between $v$ and $\V{G} \setminus{D}$ produces a graph which is also in $\Pi$, then $\Pi$ is said to be characterized by $c_{\Pi}$ adjacencies.
\end{definition}

Consider the following problem, defined with respect to a graph class $\Pi$ characterized by $c_{\Pi}$ adjacencies.
\begin{description}
	\item[$\pIndPiFDS$]\hfill\\
		$\pi$ is a class of \emph{non-empty} graphs and there is a non-decreasing polynomial $p$ such that every vertex minimal graph $G \in \Pi$ satisfies $\abs{G} \leq p(\tau)$, where $\tau$ is the size of a minimum vertex cover for $G$.\\
		\textbf{Instance:} $(G, k)$, where $G$ is a graph and $k \in \N$\\
		\textbf{Question:} Is there a set $S \subseteq V$ with $\abs{S} \leq k$ such that $G - S$ includes no graph in $\Pi$ as an induced subgraph?
\end{description}

Fomin et al.~\cite{FJP2014JCSS} give a generic procedure \algo{Reduce} (see Appendix~\ref{apdx:vc_param}), which kernelizes the problem as described in the following proposition.

\begin{proposition}[Theorem 2, Fomin et al.~\cite{FJP2014JCSS}]\label{prop:reduce_pvc_kernels}
	For an instance $(G, k)$ of $\pIndPiFDS$ with a vertex cover $X$ of size $r \geq k$, \algoi{Reduce}{$G, X, r + p(r), c_{\Pi}$} produces a kernel of size ${r}^{c_{\Pi}} (r + p(r))$.
\end{proposition}

We now state the main result of this section, which is obtained by carefully combining the logarithmic-space $\pVC$ kernelization from earlier with a modified \algo{Reduce} procedure.
\begin{theorem}\label{thm:kern_pvc}
	$\pIndPiFDS$ is in $\cParaL$.
\end{theorem}

While the \algo{Reduce} procedure of Fomin et al.~\cite{FJP2014JCSS} can be used to kernelize $\pIndPiFDS$, it is not clear that the procedure can be carried out in small space. We use a modified reduction procedure \algo{ReduceLog} (see Appendix~\ref{apdx:vc_param}) instead, which uses space $\Oh{\log{n}}$, where $n$ is the order of the input graph.

\begin{lemma}\label{lemm:reduce_log_pvc}\exS{$\dagger$}
	For an instance $(G, k)$ of $\pIndPiFDS$ with a vertex cover $X$ of size $r \geq k$, \algoi{ReduceLog}{$G, X, r + p(r), c_{\Pi}$} produces a kernel of size ${r}^{c_{\Pi}} (r + p(r))$. The procedure uses $\Oh{\log{n}}$ bits of space, where $n = \abs{G}$.
\end{lemma}

The proof of Theorem~\ref{thm:kern_pvc} is now straightforward.

\begin{proof}[Theorem~\ref{thm:kern_pvc}]
	Lemma~\ref{lemm:reduce_log_pvc} shows that given access to the input instance $(G, k)$ and a vertex cover $X$ for $G$, $\pIndPiFDS$ is kernelizable (using \algo{ReduceLog}) in space $\Oh{\log{n}}$, where $n = \abs{G}$. For a solution-size value $k$ (the size of the vertex cover), the $\pVC$ kernelization of Proposition~\ref{prop:vc_para-l} either correctly determines that $G$ has no vertex cover of size $k$ or produces a kernel $G'$ with $\Oh{k^2}$ vertices. In this case, the vertex set of $G'$ is also a vertex cover for $G$ (Proposition~\ref{prop:vc_para-l}).

	Running \algo{ReduceLog} on $(G, k)$ with access to $X = \V{G'}$ ($r = \abs{X} = \Oh{k^2}$) thus produces a kernel of size $r^{c_{\Pi}} (r + p(r)) = \Oh{k^{2 c_{\Pi}} (k^2 + p(k^2))}$ for $\pIndPiFDS$. Oracle access to $X = \V{G'}$ can be be provided using space $\Oh{\log{n}}$ and $\algo{ReduceLog}$ uses space $\Oh{\log{n}}$, so the total space used is $\Oh{\log{n}}$. By Theorem~\ref{lemm:para-l_kern}, any problem that can be kernelized in space $\Oh{\log{n}}$ is in $\cParaL$, and thus the claim is true.
\end{proof}

The following corollary to Theorem~\ref{thm:kern_pvc} shows how various deletion problems are in $\cParaL$ via formulations as $\pIndPiFDS$ for suitable $\Pi$.
\begin{corollary}\label{corr:vc_pidel}\exS{$\dagger$}
	Under the vertex-cover parameterization, $\pPlan$, $\pOCT$ and $\pChVD$ are in $\cParaL$.
\end{corollary}

Via formulations as the alternative intermediate problems $\pLIndPiS$ and $\pqPartDisjPiFree$ (defined in Appendix~\ref{apdx:vc_param}), the same \algoi{ReduceLog}{$G, X, l, c_{\Pi}$} procedure with different values for $l$ can also be used to prove the next result.
\begin{corollary}\label{corr:vc_rest_gen}\exS{$\dagger$}
	Under the vertex-cover parameterization, $\pFVS$, $\pLongPath$, $\pLongCycle$ and $\pdCol$ are in $\cParaL$.
\end{corollary} \section{Solving $\pFVS$ in $5^k \cdot n^{\Oh{1}}$ time and $\Oh{k \cdot \log{n}}$ space}\label{sect:fvs}
It is known (Lemma~\ref{naivespace}) that problems in $\cFPT$ can be solved in space $f(k) + n^{\Oh{1}}$. If the sole objective is space efficiency, many problems can also be solved (na\"{i}vely, by running over all subsets of size at most $k$, for example) in $f(k) \cdot \log{n}$ bits of space, which puts them in $\cXL$. It is pertinent to note that $\cXL$ also contains problems like $\pIS$ and $\pClq$ which are $\probc{W}[1]$-complete, and hence are unlikely to be in $\cFPT$. On the other hand, it is believed that not all problems in $\cFPT$ can be solved in $f(k) \cdot \log{n}$ bits of space~\cite{CCDF1997AnnPureApplLogic}.

A third class, which requires problems in it to be simultaneously solvable in time $f(k) \cdot n^{\Oh{1}}$ and $g(k) \cdot \log{n}$ bits of space also exists, and contains $\pFVS$~\cite{EST2015Algorithmica} and $\pMOdS$~\cite{ABB+2019FSTTCS}. This class, which we call $\cFPTXL$, has been previously identified in the literature as $D[f \oper{poly}, f \oper{log}]$~\cite{EST2015Algorithmica}.

In what follows, we devise an $\cFPTXL$ algorithm for $\pFVS$ which runs in time $5^k \cdot n^{\Oh{1}}$ and uses $\Oh{k \log{n}}$ bits of space. This improves on an earlier $((2k)^k \cdot n^{\Oh{1}})$-time,  $\Oh{k \log{n}}$-space algorithm of Elberfeld et al.~\cite{EST2015Algorithmica}. Along the way, we also devise a much simpler $(3k)^k \cdot n^{\Oh{1}}$-time $\cFPTXL$ algorithm for the problem.

Known $\cFPT$ algorithms for $\pFVS$~\cite{RSS2006TALG,CFK+2015book} are based on reduction rules, one of which is the following  ``short circuiting'' rule for vertices of degree two.

\subsubsection{Degree--$2$ Reduction Rule} If there is a vertex $x$ of degree $2$ with neighbours $y$ and $z$, delete $x$ and add an edge between $y$ and $z$, while retaining pre-existing edges.

Once the rule is applied, the graph possibly has parallel edges, so we assume throughout this section that we work with multigraphs. Additionally, we can assume that the graph has no isolated or degree-$1$ vertices (as they can be safely removed), no vertices with self-loops (as they must be included in the solution and then removed) and no more than two edges between a pair of vertices (as other multi-edges do not influence the solution can be removed). The correctness of these assumptions and the rule is easy to see~\cite{CFK+2015book}.

We first discuss the space-efficient application of these rules. The degree of a vertex can be found from the adjacency list, and so it is easy to `discard' vertices with degree at most one.
Let us remark that our algorithms (in the next subsection) deletes some (up to $k$) vertices and recursively applies these rules. Those deleted vertices are stored in a separate array using $\Oh{k \log n}$ bits, and so when checking for the degree of a vertex, we also check that array appropriately besides checking the read-only adjacency list of the graph.
one

\begin{proposition}[Elberfeld et al.~\cite{EST2015Algorithmica}, Theorem 4.13]\label{degreetwoimpl}
    On a multigraph with $n$ vertices, the Degree--$2$ rule can be applied using $\Oh{\log{n}}$ bits of additional space.
\end{proposition}

One can combine this proposition with a simple branching strategy to show that $\pFVS$ is in $\cFPTXL$.

\begin{theorem}\exS{$\dagger$}
    $\pFVS$ can be solved in time ${(3k)}^k \cdot n^{\Oh{1}}$ using $\Oh{k \log{n}}$ bits of space.
\end{theorem}

\subsection{Improved algorithm based on Iterative Compression}
We now describe a restricted-space implementation of an algorithm of Chen et al.~\cite{CFL+2008JCSS} which allows us to prove the following result.
\begin{theorem}~\label{iteratefvs}
    $\pFVS$ can be solved using $O(k \log{n})$ bits of space and in time $5^k poly(n)$.
\end{theorem}

The algorithm goes through a two stage process on an instance $(G, k)$.

\textbf{Iterative Stage} In the iterative stage, the algorithm starts with an arbitrary induced subgraph $H_0$ of $G$ with $k + 1$ vertices. The vertex set of this graph is trivially also a feedback vertex set for $H_0$. The algorithm uses a \emph{compression} algorithm which given a subgraph $H$ of $G$, and a feedback vertex set $C$ for $H$ of size $k+1$, either produces a feedback vertex set $C'$ for $H$ of size at most $k$ or determines correctly that such a feedback vertex set for $H$ does not exist. In the latter case, we correctly conclude that even $G$ has no feedback vertex set of size $k$. In the former case, both the subgraph and the (compressed) solution are included an additional vertex from the graph, and the compression step is applied again. This process continues until we cover the entire graph. During the iteration, the $(k+1)$-sized solution is stored using $O(k \log n)$ bits of space.

\textbf{Compression Stage} The compression algorithm is given a feedback vertex set $S$ of size $k+1$ for the whole graph $G$, and the goal is to determine whether it has a feedback vertex set of size at most $k$. It starts by checking for every subset $Z$ of $S$ of size at most $k$ whether there is a feedback vertex set of size at most $k$ containing $Z$. This requires storing the set $Z$ which uses $\Oh{k \log{n}}$ bits of space, and requires that $G[P]$ is a forest where $P=S\setminus Z$ which can be checked using $\Oh{\log{n}}$ bits of space (by making $\Oh{n^2}$ connectivity queries on $G[P]$). Recall that $G[V\setminus S]$ is a forest as $S$ is a feedback vertex set.

Next, as a processing step, we include all vertices $v$ of $V\setminus S$ into the solution, if $v$ has at least two neighbors in a connected component of $G[P]$ which can be checked in $\Oh{\log{n}}$ bits of space using Reingold's connectivity algorithm~\cite{Rei2008JACM}. Then for any leaf vertex $v$ in $G[V\setminus S]$, we simply branch by picking $v$ into the solution or excluding $v$ from the solution which involves including $v$ into $P$. If either branch returns \NO{}, we return \NO{}. The depth of the recursion is at most $k$ and each level uses $\Oh{\log{n}}$ bits of space, so the overall process uses $\Oh{k \log{n}}$ bits of space.

Observe that both the iterative and compression stages use $\Oh{k \log{n}}$ bits of space overall. Appendix~\ref{apdx:fvs_compress} gives pseudocode (\algo{FVSCompress}, Procedure~\ref{proc:CompressFVS}) for the compression procedure described above. For proof of correctness, we refer the reader to Chen et al.~\cite{CFL+2008JCSS}, who also prove a running time bound of $5^k \cdot n^{\Oh{1}}$ which readily carries over to this setting. We now have the following lemma.

\begin{lemma}
    \algo{FVSCompress} solves instances $(G, S, k)$ using $O(k \log{n})$ bits in time $5^k poly(n)$.
\end{lemma}

The compression procedure is called at most $n - k$ times (to include one additional vertex each time starting with the first $(k + 1)$-sized subgraph), and each time it drops a vertex and adds a new vertex, with at most $k+1$ vertices at any point of time. Thus, the iterative stage adds only an overhead of $n^{\Oh{1}}$ to the running time of \algo{FVSCompress}, and Theorem~\ref{iteratefvs} follows.

The routine either stops at an intermediate stage and declares that $(G, k)$ is a \NO{} instance or continues until $i = n$, at which stage it returns the output $T_n$ of the compression routine as a feedback vertex set for $G$ of size at most $k$.