Constant Amortized Time Enumeration of Independent Sets for Graphs with Bounded Clique Number

TL;DR

This paper introduces an efficient algorithm for enumerating independent sets in graphs with bounded clique number, achieving constant amortized time and linear space, applicable to various graph classes.

Contribution

The paper presents $ exttt{EIS}$, a novel algorithm for non-maximal independent set enumeration with optimal amortized time for graphs with bounded clique number.

Findings

Runs in $O(q)$ amortized time where $q$ is the clique number

Works correctly even without knowing the exact clique number

Applicable to various graph classes like triangle-free, planar, and $F$-free graphs

Abstract

In this study, we address the independent set enumeration problem. Although several efficient enumeration algorithms and careful analyses have been proposed for maximal independent sets, no fine-grained analysis has been given for the non-maximal variant. From the main result, we propose an algorithm $\texttt{EIS}$ for the non-maximal variant that runs in $O(q)$ amortized time and linear space, where $q$ is the clique number, i.e., the maximum size of a clique in an input graph. Note that $\texttt{EIS}$ works correctly even if the exact value of $q$ is unknown. Despite its simplicity, $\texttt{EIS}$ is optimal for graphs with a bounded clique number, such as, triangle-free graphs, planar graphs, bounded degenerate graphs, locally bounded expansion graphs, and $F$-free graphs for any fixed graph $F$, where a $F$-free graph is a graph that has no copy of $F$ as a subgraph.

Equations

$$\overline{T}(X)$$

$$\overline{T}(X)-\alpha T(X)+\beta (n_X+1)T^{\ast }\ge n_X(n_X+1)(n_X+2)/6q^2-q/6-1-3n_X^2/2+6q{n}_X+6q.$$

$$n_X(n_X+1)(n_X+2)/6q^2-q/6-1-3n_X^2/2+6q{n}_X+6q$$

$$>n_X(n_X+1)(n_X+2)/6q^2-3n_X^2/2+6q{n}_X$$

$$\ge n_X\left((n_X+1)(n_X+2)/6q^2-3n_X/2+6q\right)$$

$$>2q(2/3+3q)>0.$$

Full text

1 Introduction

A subgraph enumeration problem is defined as follows: Given a graph $G$ and a constraint $\mathcal{R}$, the task is to output all subgraphs in $G$ that satisfy $\mathcal{R}$ without duplication. We call an algorithm for an enumeration problem an enumeration algorithm. Enumeration problems have been widely studied, both in theory and practice, since 1950. The independent set enumeration problem is one of the central problems in the enumeration and several enumeration algorithms have been proposed for the maximal or maximum independent set enumeration problem [Tsukiyama:Ide:SICOMP:1977, Alessio:Roberto:SPIRE:2017, Beigel:SODA:1999, Eppstein:JGAA:2003]. In particular, theoretically efficient algorithms are developed by restricting the class of input graphs, e.g., chordal graphs [Okamoto:JDA:2008, Leung:JA:1984], circular arc graphs [Leung:JA:1984], bipartite graphs [Kashiwabara:JA:1992], and claw-free graphs [Minty:JCT:1980]. Another important object to be enumerated is a clique, that is, the independent set of the compliment graph of a given graph. Several efficient algorithms exist for the maximal enumeration problem [Tomita:TCS:2006, Makino:Uno:SWAT:2004, Alessio:Roberto:ICALP:2016]. Since every non-maximal independent set is a subset of some maximal ones, using the above results, we can find all non-maximal solutions. However, it is difficult to avoid to output duplication efficiently. Moreover, even though there are many efficient algorithms for maximal variant, no fine-grained analysis has been given for non-maximal variant. Thus, this study aims to develop an efficient algorithm for the independent set enumeration problem, which also demands the output of non-maximal solutions.

Generally, the number of solutions to an enumeration problem is exponential in the size of the input. If the number of solutions is much smaller, then it becomes unsuitable to evaluate the efficiency of an enumeration algorithm by the size $n$ of an input only since this can sometimes yield a trivial bound, such as $O\left(2^{n}\right)$ time. In this paper, we evaluate the efficiency of an enumeration algorithm by both the size $n$ of the input and the number $M$ of solutions. We call this analysis output sensitive analysis [Johnson:Yannakakis:Papadimitriou:IPL:1988]. Let $\mathcal{A}$ be an enumeration algorithm; $\mathcal{A}$ is an output polynomial time algorithm if the algorithm runs in $O\left(poly(n,M)\right)$ time. $\mathcal{A}$ is a polynomial amortized time algorithm if the running time is bounded by $O\left(M\cdot poly(n)\right)$, that is, $\mathcal{A}$ runs in $O\left(poly(n)\right)$ time per solution on average. $\mathcal{A}$ runs in $O\left(poly(n)\right)$ delay if the interval between two consecutive solutions can be bounded by $O\left(poly(n)\right)$ time and the preprocessing time and postprocessing time are also bounded by polynomial in $n$. Note that an polynomial amortized time algorithm does not guarantee that the maximum interval between two consecutive outputs, called the delay, is polynomial. So far, several frameworks and a complexity analysis technique have been proposed for developing efficient enumeration algorithms [Avis:Fukuda:DAM:1996, Conte:Uno:STOC:2019, Cohen:Kimefeld:Sagiv:JCSS:2008, Conte:Grossi:Marino:Versari:SIAM:JoDM:2019, Uno:WADS:2015]. These frameworks have been used to develop several efficient output-sensitive enumeration algorithms, especially for sparse input graphs [Wasa:Arimura:Uno:ISAAC:2014, Wasa:COCOON:2018, Kazuhiro:ISAAC:2018, Alessio:Roberto:ICALP:2016, Manoussakis:TCS:2018, Bonamy:Defrain:Heinrich:Raymond:STACS:2019]. However, as will be shown later, simply applying the above results cannot generate an efficient algorithm for the independent set enumeration problem.

1.1 Main results

In this paper, we focus on $K_{q}$-free graphs, which are graphs that have no cliques with size $q$ as subgraphs. Note that every graph is $K_{q}$-free for some $q$ (e.g., $q=n+1$). In addition, it is known that if a graph $G$ does not have a clique with size $q$, then $G$ belongs to some sparse graph class, such as, triangle-free graphs ($q=3$), planar graphs ($q=5$ since they do not have both $K_{5}$ and $K_{3,3}$), locally bounded expansion graphs ($q=f(1,0)+1$ for some function $f(\cdot)$), bounded degenerate graphs ($q$ is at most the degeneracy plus one), $F$-free graphs for some fixed graph $F$ ($q$ is the size of $F$), etc (Figure 1), where an $F$-free graph is a graph that has no copy of $F$ as a subgraph. Using the main result of this paper, we propose an algorithm EIS called for the independent set enumeration problem that runs in $O\left(q\right)$ amortized time with linear space. EIS is optimal for these graph classes. Note that a complete graph with $q$ vertices contains any graph with $q$ vertices as a subgraph, thus if $q=\left|F\right|$, then EIS is optimal for $F$-free graphs. We emphasize that EIS works correctly even if the exact value of $q$ is unknown.

EIS is simple binary partition. The algorithm starts with $(G,S=\emptyset)$, where $G$ is an $n$-vertex graph. First, EIS outputs $S$ and computes a vertex sequence $(v_{1},\dots,v_{n})$ of $G$, sorted by a smallest-last ordering [Matula:Beck:JACM:1983]. Next, EIS generates $n$ pairs, made of a subsolution and its corresponding graph $S_{1}=S\cup\{v_{1}\}$ and $G_{1}=G\setminus N[v_{1}]$, $S_{2}=S\cup\{v_{2}\}$ and $G_{2}=G\setminus(\{v_{1}\}\cup N[v_{2}])$, $\dots$, and $S_{n}=S\cup\{v_{n}\}$ and $G_{n}=G\setminus(\{v_{1},\dots,v_{n-1}\}\cup N[v_{n}])$. Then, for each pair, EIS makes recursive calls and repeats the above operations. We call this generation step an iteration. It can be easily shown that this algorithm runs in $O\left(\Delta^{2}\right)$ amortized time since each iteration has new $n$ child iterations and needs $O\left(n\Delta^{2}\right)$ time to generate all the children. However, this naive analysis is too pessimistic since the number of vertices whose degree are $\Delta$ may be small. For example, if $G$ is a star with $n-1$ leaves that has a vertex with degree $n-1$, then the number of solutions is $O\left(2^{n-1}\right)$. The first iteration of the algorithm requires $O\left(n^{2}\right)$ time to generate all the children, while other iterations require $O\left(\left|ch\right|\right)$ time since any subset of the remaining vertices makes a new solution, where $ch$ is the set of child iterations. Thus, the total time complexity is $O\left(M-1+n^{2}\right)$, i.e., EIS runs in $O\left(1\right)$ time per solution on average. As described above, if $G$ has many vertices with small degree, then the simple analysis appears not to be tight. Conversely, if $G$ has no vertices with small degree, then $G$ has a large clique from Turán’s theorem [Turan:1941]. From this observation, we focus on the clique number of an input graph to give a tight complexity bound.

The analysis is based on the push out amortization technique [Uno:WADS:2015], however, it is difficult to directly apply the technique to the proposed algorithm. To apply this technique, we focus on the size of the input graph for an iteration. If an input graph is sparse, then there are many iterations with small input graphs, e.g., the size is constant, hence the sum of the computation time for these iterations dominates the total computation time for EIS. In particular, we regard a graph as a small graph if the graph has at most $2q$ vertices. Otherwise, the graph is large. Surprisingly, the algorithm correctly works even if the location of the boundary is unknown, that is, the size of a maximum clique. In addition, by using run-length encoding, we show that EIS uses only linear space in total. Due to space limitations, all proofs are given in the Appendix.

2 Preliminaries

Let $G=(V(G),E(G))$ be a simple undirected graph, i.e., $G$ has no self loops and multiple edges, where $V(G)$ and $E(G)$ are the set of vertices and edges of $G$, respectively. Let $n$ denote the number of vertices in $G$ and $m$ the number of edges in $G$. Let $u$ and $v$ be vertices in $G$; $u$ and $v$ are adjacent if $e=\{u,v\}\in E(G)$. We denote by $N_{G}(v)$ the set of the adjacent vertices of $v$ in $G$. We call $u$ a neighbor of $v$ in $G$ if $u\in N_{G}(v)$ and an edge $e=\{u,v\}$ an incident edge of $v$. $\left|N_{G}(v)\right|$ is the degree $d_{G}(v)$ of $v$. The degree of $G$ is the maximum degree of $v\in V(G)$. If there is no confusion, we can drop $G$ from the notations. A set of vertices $S$ of $G$ is an independent set if $G[S]$ has no edges, that is, for any pair of $u,v\in S$ is not included in $\{u,v\}\in E(G[S])$. Let $U$ be a vertex subset of $V$ and $G[U]=(U,E[U])$ be the subgraph of $G$ induced by $U$, where $E[U]=\{e\in E\mid u,v\in U\}$. For simplicity, we write $G\setminus\{v\}:=G[V\setminus\{v\}]$, and $G\setminus e:=(V,E\setminus\{e\})$. A graph $G$ is a complete graph if for any distinct pair $u,v\in V$, $\{u,v\}\in E$ and a set of vertices $S$ of $G$ is a clique if $G[S]$ is a complete graph. $K_{n}$ is expressed as a complete graph with $n$ vertices. $G$ is said to be $K_{q}$-free if $G$ has no clique with $q$ vertices. In this paper, we consider the following enumeration problem: Given an undirected graph $G$, then output all independent sets in $G$ without duplication.

3 The proposed algorithm

In this section, we present a recursive enumeration algorithm EIS based on binary partition, as shown in Algorithm 1. Binary partition is a framework for developing enumeration algorithms. We provide a high level description of our proposed algorithm EIS.

Let $\mathcal{S}$ be the solution space of the independent set problem for a given graph $G$. For each recursive call $X$, called an iteration, $X$ is associated with a graph $G$ and a solution $S$. EIS first outputs $S$ on the iteration. Next, it picks a vertex $v$ from $V$ and partitions the current solution space $\mathcal{S}$ into two distinct subspaces; one consists of solutions containing $v$ and the other consists of solutions that do not contain $v$. Then, EIS makes a new iteration $Y$ that receives $G\setminus N[v]$ and $S\cup\{v\}$. We call $Y$ a child iteration of $X$ and $X$ the parent iteration of $Y$. When backtracking from $Y$, EIS removes $v$ from $G$, picks a new vertex, and makes a new child iteration $Y^{\prime}$. Each iteration repeats the above procedure for all vertices in the input graph of the iteration. EIS builds a recursion tree $\mathcal{T}=(\mathcal{V},\mathcal{E})$, where $\mathcal{V}$ is the set of iterations and $\mathcal{E}$ is given by the parent-child relation among $\mathcal{V}$. $X$ is referred to as a leaf iteration if $X$ has no child iterations. Otherwise, it is called an internal iteration. Let $G(X)$ and $S(X)$ be the input graph and the input independent set of $X$, respectively. From the construction of EIS, we can obtain the following theorem.

Theorem 1**.**

Let $G$ be a graph. EIS enumerates all independent sets in $G$ without duplication.

Proof.

We first show EIS outputs all solutions by induction on the size of a solution $S$. We assume that all the solutions whose size are at most $k-1$ are outputted. Let $k$ be the size of $S$ and $S^{\prime}$ be a vertex set $S\setminus\{s\}$, where $s\in S$. Note that any subset of $S$ is also an independent set, and thus, $S^{\prime}$ is an independent set. From the assumption, there is an iteration $X$ which outputs $S^{\prime}$. If $G(X)$ contains $s$, then EIS outputs $S$. Otherwise, there is the lowest ancestor iteration $Z$ such that removes $s$ from $G(Z)$ in Line 1. Let $Y$ be an iteration such that $S(Y)=S(Z)\cup\{s\}$. Since $S\cap G(X)$ is an independent set in $G$, there is a descendant iteration of $Y$ which outputs $S$, i.e., all solutions are outputted.

Next, we show EIS does not output duplicate solutions. Let $X$ and $Y$ be two distinct iterations. We assume that the both output the same solution. Let $Z$ be the lowest common ancestor of $X$ and $Y$. We assume that $Z\neq X$ and $Z\neq Y$. Otherwise, the output of $X$ differs from the one of $Y$ from the construction of Algorithm 1, and this contradicts the assumption. Let $z$ be a vertex picked in $Z$ such that $z\in S(X)$. Again, from the construction of the algorithm, $Y$ does not contain $z$. Hence, this contradicts the assumption. ∎

Note that Theorem 1 holds for any ordering of the vertices in an iteration. Hence, as in Line 1, we employ the following simple picking ordering: pick a vertex with minimum degree. This ordering is known as smallest-last ordering or degeneracy ordering [Matula:Beck:JACM:1983]. Note that a smallest-last ordering is not unique since there are several vertices with the minimum degree. Thus, hereafter, we fix some deterministic procedure to uniquely determine the smallest-last ordering of $G(X)$.

4 Time complexity

In this section, we analyze the time complexity of EIS. In the following, we restrict an input graph to be $K_{q}$-free. Note that every graph is $K_{q}$-free for some $q$ (for example, $q=n+1$), hence, the result is true for all graphs. We first give a brief overview of our time complexity analysis, as shown in Figure 2. The left part of the figure is the recursion tree $\mathcal{T}$ made by EIS. In our analysis, we push a part of the computational cost of an iteration to its child iterations. The remaining cost is received by the iteration itself. The key point is to use different distribution rules from the gray area and the white area. The boundary between these areas is defined by the size of the input graph of an iteration. More precisely, the gray area contains iterations whose input graphs have less than or equal to $2q$ vertices (Sect. 4.1), and the white area contains iterations whose input graphs have more than $2q$ vertices (Sect. 4.2). This boundary on $\mathcal{T}$ gives a sophisticated time complexity analysis. A simple amortization analysis can be applied in the gray area. In the white area, the push out amortization technique [Uno:WADS:2015] is used to design the cost distribution rule.

The right part shows how to push the computational cost from the iteration of the white area to that of the gray area. Gray rectangles represent costs pushed to the child iterations, while white rectangles represent costs received by the iteration itself. By using the push out amortization technique, we can show that an iteration $L_{i}$ receives only $O\left(T(L_{i})\right)$ computational time from its parent, where $T(L_{i})$ is the computation time of $L_{i}$. That is, the delivered cost $O\left(T(L_{i})\right)$ does not worsen the time complexity of $L_{i}$.

In the following, we provide the detailed description of our analysis. Assume that we use an adjacency matrix for storing the input graph. For simplicity, we write $V(X)=V(G(X))$ and $E(X)=E(G(X))$. Let $n_{X}=\left|V(X)\right|$, $m_{X}=\left|E(X)\right|$, $ch(X)$ be the set of children of $X$, and $\mathcal{T}(X)$ be the recursive subtree of $\mathcal{T}$ rooted $X$. The next lemma is easy but plays a key role in this section:

Lemma 2**.**

The total computation time of $\mathcal{T}(X)$ can be bounded by $O\left(\left|\mathcal{T}(X)\right|n_{X}\right)$.

Proof.

Let $\mathcal{V}(X)$ be the set of iterations on $\mathcal{T}(X)$. For each iteration $Y$ in $\mathcal{V}(X)$, since each picked vertex $v$ on $Y$ generates a new child iteration, $Y$ needs $O\left(\left|ch(Y)\right|n_{Y}\right)$ time, and thus, the total time of EIS for $\mathcal{T}(X)$ is $O\left(\sum_{Y\in\mathcal{V}(X)}\left|ch(Y)\right|n_{Y}\right)$. Note that $\sum_{Y\in\mathcal{V}(X)}\left|ch(Y)\right|=O\left(\left|\mathcal{V}(X)\right|\right)$. In addition, each iteration has the corresponding solution and $n_{X}\geq n_{Y}$ for any descendant iteration $Y$ of $X$. Hence, the total time complexity is $O\left(\left|\mathcal{T}(X)\right|n_{X}\right)$. ∎

4.1 Case: $n_{X}\leq 2q$

From Lemma 2, if $X$ satisfies $n_{X}\leq 2q$, then the total time complexity of $\mathcal{T}(X)$ is $O\left(q\right)$ time on average. Note that for any descendant iteration $Y$ of $X$, since $n_{Y}\leq n_{X}$, if $n_{X}\leq 2q$, then $n_{Y}\leq 2q$. Thus, the time complexity of $Y$ is also $O\left(q\right)$ time on average if $X$ satisfies the condition.

4.2 Case: $n_{X}>2q$

In this subsection, we use the push out amortization [Uno:WADS:2015] to analyze the case $n_{X}>2q$. This is one of the general techniques for analyzing the time complexity of enumeration algorithms. Intuitively, if an enumeration algorithm satisfies the PO condition, the total time complexity of the algorithm can be bounded by the sum of the time complexity of leaf iterations with small time complexity. The PO condition is defined as follows: For any internal iteration $X$, $\overline{T}(X)\geq\alpha T(X)-\beta(\left|ch(X)\right|+1)T^{*}$. Here, $T^{*}$ represents the maximum time complexity among the leaf iterations, $\alpha>1$ and $\beta\geq 0$ denotes some constants, $T(X)$ represents the time complexity of $X$, and $\overline{T}(X)$ is the total computation time of child iterations of $X$. Note that if $T^{*}$ is large, then each internal iteration can more readily push its computation time out to its child iterations more.

We first explain the outline of the push out amortization. In [Uno:WADS:2015], Uno gives a concrete computation time distribution rule for this amortization. Let $\rho(X)$ be a computation time that is pushed out from the parent of $X$ and toward $X$. Hence, $X$ now has $T(X)+\rho(X)$ as its total computation time. To achieve $O\left(T^{*}\right)$ time per solution on average, the computation time of $T(X)+\rho(X)$ is delivered as follows: (D1) $X$ receives $\hat{T}(X)=\frac{\beta(\left|ch(X)\right|+1)T^{*}}{(\alpha-1)}$ and (D2) each child iteration $Y$ of $X$ receives the remaining computation time of $\rho(Y)=\left(T(X)+\rho(X)-\hat{T}(X)\right)\frac{T(Y)}{\overline{T}(X)}$. In reality, since the sum of the number of child iterations of all iterations in $\mathcal{T}$ does not exceed the number of solutions, each iteration receives $O\left(T^{*}\right)$ as (D1) on average. In addition, if the algorithm satisfies the PO condition, then $\rho(Y)\leq T(X)/(\alpha-1)$. The reader should refer to [Uno:WADS:2015] for more details. In the following, we show that EIS satisfies the PO condition. For the following discussion, we introduce some notations. Let $V_{i:j}=\{v_{k}\in V\mid i\leq k\leq j\}$ and $v_{i}$ be a vertex with minimum degree in $V_{i:n}$. We denote the subgraph of $G$ induced by $V(X)\setminus V(X)_{1:i-1}$ by $G_{i}(X)$.

We first consider the number of vertices of a child iteration. After picking a vertex with minimum degree in $G(X)$, $X$ removes its neighborhood from $G(X)$. Thus, for each $1\leq i\leq n_{X}$, the size of the input graph for the $i$-th children $Y_{i}$ of $X$ is $(n_{X}-i+1)-d_{G_{i}(X)}(v_{i})$. Now, assume that the lower bound of the time complexity in each iteration $X$ is $\Omega(n_{X}^{2})$. Clearly, this assumption does not improve the time complexity of EIS. Thus, the following equation holds for the total time complexity of all the child iterations: $\overline{T}(X)=\Theta\left(\sum_{1\leq i\leq n_{X}}(n_{X}-i+1-d_{G_{i}(X)}(v_{i}))^{2}\right)$.

Next, we consider the lower bound of $n_{X}-i+1-d_{G_{i}(X)}(v_{i})$ for each $1\leq i\leq n_{X}$. Let $\mathcal{V}^{\prime}=\{X\in\mathcal{V}\mid n_{X}>2q\}$. Since the size of the input of an iteration is smaller than the size of an ancestor, $\mathcal{T}^{\prime}=\mathcal{T}[\mathcal{V}^{\prime}\cup ch(\mathcal{V}^{\prime})]$ forms a tree, where $ch(\mathcal{V}^{\prime})=\bigcup_{X\in\mathcal{V}^{\prime}}ch(X)\setminus\mathcal{V}^{\prime}$. Thus, we can use the push out amortization technique to analyze this case. Since $G$ has no large clique, the upper bound of $d_{G_{i}(X)}(v_{i})$ is obtained from Lemma 4. This lemma can easily be derived from Theorem 3 that is shown by Turán. Let $\tau=(q-1)/q$.

Theorem 3** ((Turán’s Theorem [Turan:1941])).**

For any integer $q$ and $n$, a graph $G$ that does not contain $K_{q}$ as a subgraph has at most $\frac{n^{2}\tau}{2}$ edges.

Lemma 4**.**

Let $G$ be a graph and $v$ be a vertex with the minimum degree in $G$. If the size of a maximum clique in $G$ is at most $q-1$, then $d(v)\leq n\tau$, where $n$ is the number of vertices in $G$.

Proof.

If the minimum degree of $G$ is more than $n\tau$, then $G$ has more than $\frac{n^{2}\tau}{2}$ edges. This contradicts Theorem 3 and the statement holds. ∎

Using this upper bound, we show the following lemma which implies that if the size of the input graph of $X$ is large enough, that is, $n_{X}>2q$, then the total computation time of all the child iterations of $X$ consumes more than that of $X$.

Lemma 5**.**

Let $X$ be an internal iteration in $\mathcal{T}^{\prime}$. There exists a constant $c>0$ such that $\overline{T}(X)>c(n_{X}(n_{X}+1)(n_{X}+2)/6q^{2}-q/6-1)$.

Proof.

Let $n_{X}$ be the number of vertices in $G(X)$ and $i$ be an integer. If $i<n_{X}-q$, then $(n_{X}-i-d_{G_{i}(X)}(v_{i}))^{2}>(n_{X}-i+1-(n_{X}-i+1)\tau)^{2}$ from Lemma 4. Hence, $\overline{T}(X)\geq c\sum_{1\leq i\leq n_{X}-q-1}((n_{X}-i+1)-(n_{X}-i+1)\tau)^{2}$ since $((n_{X}-i+1)-d_{G_{i}(X)}(v_{i}))$ is non negative for any $i$. Therefore,

[TABLE]

holds. Thus, the statement holds. ∎

Using Lemma 5, we can show that by choosing appropriate values for $\alpha$, $\beta$, and $T^{*}$, any internal iteration of $\mathcal{T}^{\prime}$ satisfies the PO condition.

Lemma 6**.**

Suppose that $\alpha=3/2$, $\beta=6$, and $T^{*}=cq$ for some positive constant $c$, then, any internal iteration $X$ in $\mathcal{T}^{\prime}$ with $n_{X}\geq 2q$ satisfies the PO condition, that is, $\overline{T}(X)\geq\alpha T(X)-\beta(n_{X}+1)T^{*}$.

Proof.

From Lemma 5, there exists $c$ such that $\overline{T}(X)>c(n_{X}(n_{X}+1)(n_{X}+2)/6q^{2}-q/6-1)$ holds. Hence,

[TABLE]

The right hand side of Eq. (1) is minimum when $n_{X}=2q$ since the side is monotonically increasing for $n_{X}\geq 2q$. Hence,

[TABLE]

Therefore, any internal iteration $X\in\mathcal{T}^{\prime}$ satisfies the PO condition and the statement holds. ∎

Recall that any leaf iteration $L$ receives $O\left(\beta T(L)/(\alpha-1)\right)$ computation time from the parent. Hence, the following lemma holds.

Lemma 7**.**

Let $L$ be a leaf iteration of $\mathcal{T}^{\prime}$ and $X$ be an internal iteration of $\mathcal{T}^{\prime}$. Then, $L$ receives $O\left(T(L)\right)$ computational time and $X$ needs $O\left(q\right)$ time.

Proof.

From Lemma 6, any internal iteration in $\mathcal{T}^{\prime}$ satisfies the PO condition. Remind that any leaf iteration $L$ receives at most $O\left(\beta T(L)/(\alpha-1)\right)=O\left(T(L)\right)$ time since $\alpha$ and $\beta$ are positive constants. In addition, each internal iteration $X$ of $\mathcal{T}^{\prime}$ has $\beta T^{*}/(\alpha-1)=O\left(q\right)$. Thus, the statement holds. ∎

From Lemma 6 and the distribution rule, any internal iteration in $\mathcal{T}^{\prime}$ has at most $O\left(q\right)$ computation time on average. In addition, any leaf iteration $L$ in $\mathcal{T}^{\prime}$ has at most $O\left(T(L)\right)$ computation time. Note that from the definition, $T(L)=O\left(n^{2}_{L}\right)=O\left(ch(L)n_{L}\right)=O\left(ch(L)q\right)$. From Lemma 2 and Lemma 7, we can show the following main theorem.

Theorem 8**.**

EIS* enumerates all independent sets in $O\left(q\right)$ amortized time even if the exact value of $q$ is unknown.*

Proof.

From Lemma 2, the time complexity of each iteration in $\mathcal{T}(X)$ is $O\left(n_{X}\right)$ time on average. From Lemma 7, $X$ receives at most $O\left(T(X)\right)$ time from the parent. Hence, if $n_{X}\leq 2q$, then from Lemma 2, any descendant iteration of $X$ has $O\left(q\right)$ computation time. If $n_{X}>2q$, then from Lemma 6 and the distribution rule of the computational cost, any $X$ has $O\left(q\right)$ time on average. Note that the difference between $S(X)$ and $S(Y)$ is exactly one vertex for any iteration $X$ and its child iteration $Y$. Thus, the total size of what EIS outputs is bounded by the number of iteration of EIS. Therefore, by outputting only the difference between the $i$-th solution and the $i+1$-th solution instead of the $i+1$-th solution, the amortized time complexity of EIS is $O\left(q\right)$ time and the statement holds. ∎

5 A linear space implementation of EIS

In this section, we show that we can implement EIS in linear space. The main space bottleneck associated with EIS relates to the following two points: One is the representation of input graphs. If we naively employ an adjacency matrix to represent an input graph, EIS uses $O\left(n^{2}\right)$ space. However, if we employ an adjacent list, then linear space is obtained but then it becomes difficult to obtain the input graph for a child iteration $Y$ of a current iteration $X$ in $O\left(n_{Y}^{2}\right)$ from $G(X)$. Note that $G(Y)$ can easily be obtained in $O\left(n_{X}^{2}\right)$ time. The other bottleneck is related to the smallest-last ordering. If each iteration of EIS stores the smallest-last ordering, since the number of iterations between the root iteration and a leaf iteration is at most $n$, EIS needs $O\left(n^{2}\right)$ space. To overcome these difficulties and in particular, to achieve $O\left(n+m\right)$ space, we use run-length encoding for compressing an adjacency matrix and a partial smallest-ordering to store only the differences between the smallest-last orderings.

We summarize the data structures that are stored during execution of an iteration $X$ as follows. Let $Z$ be an ancestor iteration of $X$ and $Z^{\prime}$ be the parent of $Z$. Suppose that a vertex $z^{\prime}_{i}$ is picked on $Z^{\prime}$. We will provide precise definitions of these data structures in the remainder of this section. Roughly speaking, $M^{r}_{G}$ is the run-length encoded adjacent matrix, $SL(Z)$ is the smallest-last ordering of $G(Z)$, and $R^{r}(G_{i}(Z^{\prime}),G(Z),z^{\prime}_{i})$ represents the removed vertices from $Z^{\prime}$.

$M^{r}_{G_{i}(X)}$ and the smallest-last ordering of $G_{i}(X)$, 2. 2.

Vertices from the first $i$ elements on $SL(Z)$ and the position of $u$ on $SL(Z^{\prime})$ for each $u\in N[z^{\prime}_{i}]$, 3. 3.

$Q(\widehat{SL}(Z^{\prime},z^{\prime}_{i}),SL(Z))$ for restoring $SL(Z^{\prime})$ for each $Z$, 4. 4.

$M^{r}_{G_{i}(Z)}[u]$ for each $u\in N_{G_{i}(Z)}[z_{i}]$ for a picked vertex $z_{i}$, and 5. 5.

$R^{r}(G_{i}(Z^{\prime}),G(Z),z^{\prime}_{i})$ for each $u\in V\setminus N_{G_{i}(Z^{\prime})}[z^{\prime}_{i}]$.

First, we introduce the compression of input graphs by run-length encoding, which is a lossless data compression. We define run-length encoding and run-length encoded adjacency matrix. Let $Seq$ be a sequence consisting of 0 and 1. We define a run-length encoded 0-1 sequence $Seq^{r}=(a_{1},b_{1},\dots,a_{k},b_{k})$ of $Seq$ as follows: Let $a_{0}=b_{0}=0$. For $i>0$, $a_{i}$ is the length of the interval between consecutive 0 sequences starting from the $\sum_{0\leq j\leq i-1}(a_{j}+b_{j})+1$-th element in $Seq$. Similarly, $b_{i}$ is the length of the interval between consecutive 1 sequences starting from the $\sum_{0\leq j\leq i-1}(a_{j}+b_{j})+a_{i}+1$-th element in $Seq$. For example, if $Seq=(\texttt{1},\texttt{1},\texttt{1},\texttt{0},\texttt{0},\texttt{0},\texttt{1},\texttt{1},\texttt{0})$, then $Seq^{r}=(0,3,3,2,1,0)$. This is denoted by $\left|Seq^{r}\right|=2k$; let us call this the length of $Seq^{r}$. The following lemma holds for the length of $Seq^{r}$.

Lemma 9**.**

Let $Seq$ be a 0-1 sequence and $Seq^{r}$ be a run-length encoded sequence of $Seq$. Then, the length of $Seq^{r}=(a_{1},b_{1},\dots,a_{k},b_{k})$ is at most $\min\{2x_{\texttt{0}},2x_{\texttt{1}}\}+2$, where $x_{\texttt{0}}=\sum_{1\leq i\leq k}a_{i}$ and $x_{\texttt{1}}=\sum_{1\leq i\leq k}b_{i}$ is the number of 0 and 1 in $Seq$, respectively.

Proof.

Since $a_{i}>0$ for $1<i\leq k$ and $b_{i}>0$ for $1\leq i<k$, $k$ is at most $\min\{x_{\texttt{0}},x_{\texttt{1}}\}+1$. Hence, the length of $Seq^{r}$ is at most $\min\{2x_{\texttt{0}},2x_{\texttt{1}}\}+2$ and the statement holds. ∎

Let $M_{G}$ be an adjacency matrix of $G$, $M_{G}[j]$ be the $j$-th row of $M_{G}$, and let $M^{r}_{G}=(M^{r}_{G}[1],\dots,M^{r}_{G}[n])$ of $M_{G}$. We call $M^{r}_{G}$ the run-length encoded adjacency matrix of $M_{G}$. An example of a run-length encoded adjacency matrix is shown in Figure 3. The next lemma shows that the size of $M^{r}_{G}$ is linear in the size of $G$. Since $M_{G}$ is a 0-1 matrix, $M_{G}[j]$ is a 0-1 sequence with length $n$ for $1\leq j\leq n$.

Lemma 10**.**

Let $M_{G}$ be an adjacency matrix of a graph $G$. Then, $M^{r}_{G}$ needs $O\left(n+m\right)$ space, where $n$ and $m$ are the number of vertices and the number of edges, respectively.

Proof.

Since from Lemma 9, for each $1\leq j\leq n$, $\left|M^{r}_{G}[j]\right|\leq\min\{2x_{\texttt{0}},2x_{\texttt{1}}\}+2$ and $x_{\texttt{1}}=d(v_{j})$, $M^{r}_{G}[j]$ consumes $O\left(d(v_{j})\right)$ space. Thus, $M^{r}(G)$ uses $O\left(n+m\right)$ space and the statement holds. ∎

5.1 Generating the input graphs of child iterations

In this subsection, we explain how to generate child iterations with the compressed inputs. This can be done in $O\left(n_{X}^{2}\right)$ total time if EIS uses $M^{r}_{G(X)}$. To execute Line 1, we first consider how to obtain the smallest-last ordering. If the graph is stored in adjacency list representation, the ordering can be obtained in $O\left(n_{X}+m_{X}\right)$ time. Now, an adjacency list can be obtained from $M^{r}_{G(X)}$ in $O\left(n_{X}^{2}\right)$ time. Hence, we can compute the smallest-last ordering of $G(X)$ in $O\left(n_{X}^{2}\right)$ time.

Generating $M^{r}_{G_{i+1}(X)}$ can be done in $O\left(n_{X}\right)$ time since the run-length encoded sequences are ordered by the smallest-last ordering of $G(X)$, where $v_{i}$ is the first vertex in the sequences. Next, we consider how to generate $M^{r}_{G(Y_{i})}$ from $M^{r}_{G_{i}(X)}$, where $Y_{i}$ is a child iteration of $X$ in Line 1 whose input graph is obtained by removing $N[v_{i}]$ from $G_{i}(X)$. Our goal is $O\left(n_{X}+n_{Y_{i}}^{2}\right)$ time for obtaining $M^{r}_{G(Y_{i})}$. If we can achieve this computation time, then the time complexity of $X$ can be bounded by $O\left(n_{X}^{2}\right)$ by distributing $O\left(n_{Y_{i}}^{2}\right)$ computation time from $X$ to its child $Y_{i}$. From the following lemma, we can compute $M^{r}_{G(Y_{i})}$ in $O\left(n_{X}-i+\sum_{u\in V(Y_{i})}\left(\left|M^{r}_{G_{i}(X)}[u]\right|+n_{Y_{i}}\right)\right)$ time.

Lemma 11**.**

Let $G=(V,E)$ be a graph and $v$ be the vertex with minimum degree in $G$. Then, we can obtain $M^{r}_{G\setminus N[v]}$ from $M^{r}_{G}$ in $O\left(\left|V\right|+\displaystyle\sum_{w\in V\setminus N[v]}\left(\left|M^{r}_{G}[w]\right|+\left|M^{r}_{G}[v]\right|\right)\right)$ time.

Proof.

By simply scanning $M^{r}_{G}[v]$ from the first element to the last element, we can obtain $V\setminus N[v]$ in $O\left(\left|V\setminus N[v]\right|+\left|M^{r}_{G}[v]\right|\right)=O\left(\left|V\right|\right)$ time. Note that $V\setminus N[v]$ is sorted in the order of their indices.

Next, for each $w\notin N[v]$, we compute $M^{r}_{G\setminus N[v]}[w]$ from $M^{r}_{G}[w]$. Let $u_{i}$ be the $i$-th vertex in $V\setminus N[v]$, $c_{j}$ be the $j$-th element of $M^{r}_{G}[w]$, and $C_{j}=\sum_{1\leq j^{\prime}<j}c_{j^{\prime}}$. Let $M^{r}_{G\setminus N[v]}[w]=\emptyset$ and $c^{*}$ be the last element of $M^{r}_{G\setminus N[v]}[w]$. Now we can check whether $u_{i}$ and $w$ are connected or not by checking the following condition: Let $j=1$. (1) If $j$ satisfies $C_{j}\leq u_{i}<C_{j+1}$, then (1.a) if the parity of $j$ and the index of $c^{*}$ is same then increment $c^{*}$ by one; (1.b) if the parity of $j$ and the index of $c^{*}$ is not same then add $1$ as the last element to $M^{r}_{G\setminus N[v]}[w]$. (2) If $j$ does not satisfy $C_{j}\leq u_{i}<C_{j+1}$, then increment the value of $j$ by one and check above two condition. After updating the row, we continue to check $u_{i+1}$ from $c_{j}$. Now both $M^{r}_{G}[w]$ and $V\setminus N[v]$ are sorted. Hence, we can compute $M^{r}_{G\setminus N[v]}[w]$ from $M^{r}_{G}[w]$ by scanning $M^{r}_{G}[w]$ from the first element. If we apply the above procedure naively, then we need $O\left(\left|V\right|\right)$ time. However, the above procedure can be done in $O\left(\left|M^{r}_{G}[w]\right|+\left|M^{r}_{G}[w]\right|\right)$ time by processing consecutive 0s or 1s in one operation. Hence, the statement holds. ∎

Since $O\left(\sum_{u\in V(G(Y_{i}))}n_{Y_{i}}\right)=O\left(n_{Y_{i}}^{2}\right)$, we can push this computation time to $Y_{i}$. In addition, $X$ can also receive the computation time of $O\left(n_{X}-i\right)$ without worsening the computation time of $X$. Next, we analyse $O\left(\sum_{u\in V(G(Y_{i}))}\left|M^{r}_{G_{i}(X)}[u]\right|\right)$ more precisely.

Lemma 12**.**

Let $G=(V,E)$ be a graph and $v$ be a vertex with the minimum degree in $G$. Then, the length of $M^{r}_{G}[u]$ is $O\left(\left|V\setminus N[v]\right|\right)$ for any $u\in V$.

Proof.

Suppose that $u=v$. Note that $\left|V\setminus N[v]\right|$ is equal to $x_{\texttt{0}}$ in $M_{G}[u]$. Thus, from Lemma 9, the length of $M^{r}_{G}[u]$ is $O\left(\left|V\setminus N[v]\right|\right)$. Next, we assume that $u\neq v$. Since $d(v)\leq d(u)$, $\left|V\setminus N[u]\right|\leq\left|V\setminus N[v]\right|$. Hence, from Lemma 9, the length of $M^{r}_{G}[u]$ is at most $\min\{2\left|V\setminus N[u]\right|,2d(u)\}+2\leq\min\{2\left|V\setminus N[v]\right|,2d(u)\}+2$. Therefore, $\left|M^{r}_{G}[u]\right|=O\left(\left|V\setminus N[v]\right|\right)$. ∎

From Lemma 12, $\left|M^{r}_{G_{i}(X)}[u]\right|=O\left(n_{Y_{i}}\right)$ for any vertex $u$ in $V(G_{i}(X))$. Thus, $O\left(\sum_{u\in V(G(Y_{i}))}\left|M^{r}_{G_{i}(X)}[u]\right|\right)=O\left(n_{Y_{i}}^{2}\right)$ and we can push this computation time to $Y_{i}$. From the above discussion, we can compute $M^{r}_{G(Y_{i})}$ from $M^{r}_{G_{i}(X)}$ without worsening the time complexity.

5.2 Restoring the input graph of the parent iteration

In this subsection, we consider backtracking from $Y_{i}$ to $X$. The goal here is to show that the restoration of $M^{r}_{G_{i}(X)}$ from $M^{r}_{G(Y_{i})}$ can be done in $O\left(n_{X}+n_{Y_{i}}^{2}\right)$ time with $O\left(n+m\right)$ total space. To restore $M^{r}_{G_{i}(X)}$, we need to restore the smallest-last ordering in advance. Since we only consider the backtracking from $Y_{i}$ to $X$, if no confusion arises, we identify $Y_{i}$ with $Y$, $G_{i}(X)$ with $X$, and $G(Y)$ with $Y$.

5.2.1 Smallest-last orderings

If EIS stores the smallest-last ordering of $X$ from that of $Y$ when making a recursive call and discards it when backtracking, then the total space is $\Omega\left(n^{2}\right)$ since the depth of the search tree and the number of vertices of the input graphs can be $n$. Hence, to achieve $O\left(n+m\right)$ space, EIS does not entirely store the orderings, but rather stores them partially. Let $SL(X)$ and $SL(Y)$ respectively be the smallest-last ordering of $X$ and $Y$, and $v$ be the vertex such that $S(Y)=S(X)\cup\{v\}$. $\widehat{SL}(X,v)=SL(X)\setminus N_{X}[v]$ denotes the partial smallest-last ordering obtained by removing the vertices in $N_{X}[v]$ from $SL(X)$. Let $SL$ be a smallest-last ordering and $SL[i]$ be the $i$-th vertex of $SL$. We say that a sequence $SL^{\prime}$ is obtained by shifting $u$ at position $j$ to $p$ positions in $SL$ if $SL^{\prime}=(SL[1],\dots,SL[j-p-1],SL[j],SL[j-p],\dots,SL[j-1],SL[j+1],\dots,SL[n])$, and write $SL^{\prime}=op(SL,u,p)$. This is refered to as a shift operation. Let $Q(\widehat{SL}(X,v),SL(Y))$ be the sequence of pairs of a vertex and a shift value $((u_{1},p_{1}),\dots,(u_{\ell},p_{\ell}))$ with length $\ell$, such that $SL(Y)=op(op(\cdots op(\widehat{SL}(X,v),u_{1},p_{1})\cdots,u_{\ell-1},p_{\ell-1}),u_{\ell},p_{\ell})$. It can easily be shown that $Q(\widehat{SL}(X,v),SL(Y))$ can be obtained in $O\left(\left|SL(Y)\right|^{2}\right)$ time since $p_{j}$ can be obtained in $O\left(\left|SL(Y)\right|\right)$ time for each $j\in[1,\ell]$.

Lemma 13**.**

Let $X_{*}$ be the root iteration and $L$ be a leaf iteration. Suppose that $\mathcal{I}=(X_{*}=I_{1},\dots,I_{i}=L)$ is the path of iterations on $\mathcal{T}$ such that for each $1\leq j<i$, $I_{j}$ is the parent of $I_{j+1}$ and $S(I_{j+1})=S(I_{j})\cup\{v_{j}\}$. Then, $\sum_{j\in[1,i-1]}\left|Q(\widehat{SL}(I_{j},v_{j}),SL(I_{j+1}))\right|\leq m$.

Proof.

If a vertex $u$ is shifted, this implies that one of its incident edge is removed from a graph since each smallest-ordering is obtained by some fixed deterministic procedure. Thus, the number of applying shift operations is at most $d_{G}(u)$ on $\mathcal{I}$. Hence, the total number of applying shift operations is at most the number of edges in the input graph. ∎

In addition, $SL(X)$ is obtained by adding $N_{X}[v]$ to $\widehat{SL}(X,v)$ in $O\left(\left|N_{X}[v]\right|\right)$ time if for each $u\in N_{G(X)}[v]$, EIS stores the position of $u$ in $SL(X)$. This needs $O\left(n\right)$ space in total since each vertex is removed from a graph at most once on the path from a current iteration to the root iteration. Hence, from the above discussion, we can obtain the following lemma:

Lemma 14**.**

We can compute $SL(X)$ from $SL(Y)$ in $O\left(n_{X}+n_{Y}^{2}\right)$ time with $O\left(n+m\right)$ space in total when backtracking from $Y$ to $X$.

From Lemma 14, EIS demands $O\left(n+m\right)$ space and $O\left(n_{X}^{2}\right)$ time for each iteration $X$ on average for restoring the smallest-last orderings.

5.2.2 Run-length encoded adjacency matrices

In this subsection, we demonstrate how to restore each row of $M^{r}_{X}$. Let $u$ be a vertex in $V(X)$. Recall that $v$ is picked from $V(X)$ and added to $S(Y)$. If $u\notin V(Y)$, by just adding $M^{r}_{X}[u]$ to $M^{r}_{Y}[u]$, we can restore $M^{r}_{X}[u]$ since EIS keeps $M^{r}_{X}[u]$ until backtracking. In addition, once $u$ is removed from $X$, it will never appear in the input graph of a descendant iteration of $X$. Thus, EIS requires linear space in total for storing removed $M^{r}_{X}[u]$.

Suppose $u\in V(Y)$. To restore $M^{r}_{X}[u]$ by adding some vertices to $Y$, we use data structures $R(X,Y,u)$ and $R^{r}(X,Y,u)$. $R(X,Y,u)$ represents the neighborhood of $u$ that is removed from $X$ to obtain $Y$, and $R^{r}(X,Y,u)$ is its run-length encoded representation. In the following, we fix $X$, $Y$, and $u$, and we abuse notation using $R(X,Y,u)$ and $R^{r}(X,Y,u)$ to denote $R$ and $R^{r}$, respectively.

Their precise definitions are as follows: $R$ is a 0-1 sequence with length $d_{X}(v)$. The $j$-th element of $R=\texttt{1}$ if the $j$-th neighbor of $v$ in $X$ is adjacent to both $v$ and $u$ in $X$. Otherwise, $R=\texttt{0}$. $R^{r}$ is the run-length encoded sequence of $R$. By scanning $M_{X}[v]$, $R^{r}$, and $M^{r}_{Y}[u]$, from the head simultaneously, we can efficiently obtain the removed vertices from $M^{r}_{X}[u]$. Figure 4 provides an intuitive explanation of how this is achieved. The values of position 1, 2, 4, 6, and 7 of $M_{X}[u]$ come from $R$. The remaining values come from $M_{Y}[u]$.

Lemma 15**.**

Let $v$ be a vertex with the minimum degree in $X$, and $Y=X\setminus N_{X}[v]$. We assume that the followings are given: $M^{r}_{Y}$, for each $u\notin N_{X}[v]$, $R^{r}$ and the position of $u$ on the smallest-last ordering of $X$, and the smallest-last ordering of $Y$ with the shift operation sequence for the smallest-last ordering of $X$. Then, we can restore $M^{r}_{X}$ in $O\left(n_{X}+n_{Y}^{2}\right)$ time and $O\left(\left|V(X)\right|\right)$ space.

Proof.

Let $u$ be a vertex in $V(Y)$. From Lemma 14, we can obtain the smallest-last ordering of $X$ in the claimed time complexity. In addition, by scanning the smallest-last ordering of $X$ from the head, we can reorder $M^{r}_{Y}[u]$. This reorder needs $O\left(n_{X}+n_{Y}^{2}\right)$ time and $O\left(\left|V(X)\right|\right)$ space.

Next, we consider how to restore $M^{r}_{X}[u]$. If we decode $M^{r}_{X}[u]$ naively, then we need $O\left(n_{X}\right)$ time for each $u$ and $O\left(n_{X}^{2}\right)$ time in total. This may exceed $O\left(n_{X}+n_{Y}^{2}\right)$ time. Thus, we employ efficient restoring procedure, in particular, without decoding.

We first consider the restoring procedure for 0-1 sequences, i.e., non-compressed sequences. See Fig. 4 for a concrete example. To compute $M_{Y}[u]$, we first cut $M_{X}[u]$ into intervals and then concatenating some intervals. $R$ was obtained by concatenating the remaining intervals that are not included in $M_{Y}[u]$. Hence, we can restore $M_{X}[u]$ by combining $M_{Y}[u]$ and $R$. This can be done by scanning $M_{X}[v]$ from the head. Note that $M_{X}[v]$ is stored when $v$ is added to a solution. Moreover, both $M_{Y}[u]$ and $R$ are sorted in the order of $M_{X}[v]$. If a value of $M_{X}[v]$ is 1, then the corresponding value of $M_{X}[u]$ is recorded in $R$ since the corresponding vertex is adjacent to $v$ and now $v$ is in a solution. Otherwise, the corresponding value is recorded in $M_{Y}[u]$. Thus, if we meet 1 on $M_{X}[v]$, then we put the corresponding value of $R$ to $M_{X}[u]$. Otherwise, then we put the corresponding value of $M_{Y}[u]$ to $M_{X}[u]$.

This idea can be also extended to the run-length encoded sequences. Let $M_{X}[v]=(a_{1},b_{1},\dots,a_{k},b_{k})$. First, we partition $R^{r}$ into $A_{1},A_{2},\dots,A_{k^{\prime}}$ by using $a_{1},a_{2},\dots,a_{k}$ as follows:

• •

$A_{1}=(R^{r}[1],R^{r}[2],\dots,R^{r}[j_{1}],\alpha_{1})$ such that

$\displaystyle\sum_{j^{\prime}=1,\dots,j_{1}}R^{r}[j^{\prime}]\leq a_{1}<\sum_{j^{\prime}=1,\dots,j_{1}+1}R^{r}[j^{\prime}]$ and $\displaystyle a_{1}=\alpha_{1}+\sum_{j^{\prime}=1,\dots,j_{1}}R^{r}[j^{\prime}]$.

• •

$A_{i}=(R^{r}[j_{i-1}+1]-\alpha_{i-1},R^{r}[j_{i-1}+2],\dots,R^{r}[j_{i}],\alpha_{i})$ such that

$\displaystyle\sum_{j^{\prime}=j_{i-1}+1,\dots,j_{i}}R^{r}[j^{\prime}]\leq a_{i}+\alpha_{i-1}<\sum_{j^{\prime}=j_{i-1}+1,\dots,j_{i}+1}R^{r}[j^{\prime}]$ and $\displaystyle a_{i}=\alpha_{i}-\alpha_{i-1}+\sum_{j^{\prime}=j_{i-1}+1,\dots,j_{i}}R^{r}[j^{\prime}]$.

By the similar way, we also partition $M^{r}_{Y}[u]$ into $B_{1},\dots,B_{k^{\prime\prime}}$ by using $b_{1},b_{2},\dots,b_{k}$. Then, we alternatively put together $A_{1},\dots A_{k^{\prime}}$ and $B_{1},\dots,B_{k^{\prime\prime}}$ into one sequence like the non-compressed version. If the both of two consecutive values on the resultant sequence correspond to either 1 or 0, then we sum them up and replace it by the summation. In addition, $k^{\prime}$ and $k^{\prime\prime}$ can be bounded by $O\left(n_{Y}\right)$. Thus, for each $u\in Y$, this restoring can be done in $O\left(n_{Y}\right)$ time. In addition, for each $u\notin Y$, $M^{r}_{X}[u]$ is stored when $X$ calls its child iteration. Hence, we can restore $M^{r}_{X}$ in the claimed time complexity. From Lemma 10 and $n_{X}\geq n_{Y}$, the above procedure only uses $O\left(\left|V(X)\right|\right)$ space. ∎

Next, we consider the total space usage of $R^{r}$. From Lemma 11, we can easily see that we need $O\left(d_{X}(u)-d_{Y}(u)\right)$ space for storing $R^{r}$ for $u$. However, if EIS stores $R^{r}$ such that $R$ does not contain 1, then the total space cannot be bounded by $O\left(n+m\right)$ since each iteration has $O\left(n_{Y}\right)$ additional space in the worst case and $O\left(n^{2}\right)$ space in total. Hence, we store $R^{r}$ if $R$ contains at least one 1. These are stored by using a doubly linked list ordered in the smallest last ordering. Note that we now have the smallest-last ordering of $X$ from the previous subsection. Thus, by scanning the list from the head, we can easily find vertices $u$ such that $R$ consists only of 0s, and obtain $R$ by just filling 0s. Thus, EIS requires linear space for computing the data structures. In addition, the restoration of $G_{i}(X)$ from $G_{i+1}(X)$ can be done in $O\left(n_{X}\right)$ time. Combining with the discussion in the previous section, we can obtain the following theorem.

Theorem 16**.**

EIS* enumerates all independent sets in $O\left(q\right)$ time using $O\left(n+m\right)$ space even if the exact value of $q$ is unknown, where $n$ represents the number of vertices, $m$ represents the number of edges, and $q$ is the minimum number such that $G$ does not contain a clique with $q$ vertices.*

Finally, we obtain the following corollary from Theorem 16 since $K_{q}$ contains any graph with $q$ vertices as a subgraph, e.g., the graph class of $K_{5}$-free graphs contains planar graphs.

Corollary 17**.**

Let $\mathcal{R}$ be a set of graphs and $\mathcal{C}$ be a graph class such that any graph in $C$ does not have a graph in $\mathcal{R}$ as a subgraph. If $\mathcal{R}$ contains a graph with constant size, then EIS enumerates all independent sets in a given graph $G\in\mathcal{C}$ with $O\left(1\right)$ amortized time and $O\left(n+m\right)$ space.

When EIS makes an iteration $X$, the size of the input graph for $X$ is smaller than that of the parent iteration. This reducing procedure can be regarded as a kernelization technique for FPT algorithms [Niedermeier:IPL:2000]. Thus, combining this technique with push out amortization, we showed a good boundary on a recursion tree and demonstrated a sophisticated complexity analysis. Our future work will examine the possibility of applying our novel technique to other enumeration problems.

Acknowledgements

The authors thank A. Conte for helpful comments which led to improvements in this paper. This work was partially supported by JSPS KAKENHI Grant Number JP19J10761 and JP19K20350, and JST CREST Grant Number JPMJCR18K3 and JPMJCR1401, Japan.