Approximately counting and sampling small witnesses using a colourful decision oracle

TL;DR

This paper develops efficient algorithms for approximately counting and sampling edges in hypergraphs using a colourful decision oracle, extending previous work and impacting complexity theory applications.

Contribution

It introduces algorithms that convert decision procedures into approximate counting and sampling methods for hypergraphs via a colourful oracle.

Findings

Algorithms for approximate edge counting and sampling in hypergraphs.

Reduction of decision algorithms to approximate counting/sampling.

Applications to fine-grained and parameterized complexity problems.

Abstract

In this paper, we design efficient algorithms to approximately count the number of edges of a given $k$-hypergraph, and to sample an approximately uniform random edge. The hypergraph is not given explicitly, and can be accessed only through its colourful independence oracle: The colourful independence oracle returns yes or no depending on whether a given subset of the vertices contains an edge that is colourful with respect to a given vertex-colouring. Our results extend and/or strengthen recent results in the graph oracle literature due to Beame et al. (ITCS 2018), Dell and Lapinskas (STOC 2018), and Bhattacharya et al. (ISAAC 2019). Our results have consequences for approximate counting/sampling: We can turn certain kinds of decision algorithms into approximate counting/sampling algorithms without causing much overhead in the running time. We apply this approximate-counting/sampling-to-decision reduction to key problems in fine-grained complexity (such as $k$-SUM, $k$-OV and weighted $k$-Clique) and parameterised complexity (such as induced subgraphs of size $k$ or weight-$k$ solutions to CSPs).

Equations

$$\mathcal{C}(G):=\{(X_{1},\dots,X_{k})\colon\mbox{$X_{1},\dots,X_{k}$ are disjoint subsets of $V$}\}.$$

$${\epsilon }^{-2}{\log }^2(1/\delta )(k\log n{)}^{\mathcal{O}(k)}(n+T).$$

$$\varepsilon^{-2}(k_{x}\log n_{x})^{\mathcal{O}(k_{x})}\cdot\max\big{\{}T(I_{x}(S))\colon S\subseteq V(G_{x})\big{\}},$$

$$\mathbb{P}\big{(}|X-\mathbb{E}(X)|\geq t\big{)}\leq 2e^{-2t^{2}/\sum_{i=1}^{m}(b_{i}-a_{i})^{2}}.$$

$$\mathbb{P}\big{(}|X-\mathbb{E}(X)|\geq z\big{)}\leq 2\exp\Big{(}{-}\frac{3z^{2}}{6\nu+2Mz}\Big{)}.$$

$$\displaystyle\binom{2N-k}{N-k}\Big{/}\binom{2N}{N}$$

$$\displaystyle\geq\Big{(}\frac{N-k+1}{2N-k+1}\Big{)}^{k}=\Big{(}\frac{1}{2}-\frac{k-1}{2(2N-k+1)}\Big{)}^{k}$$

$$\displaystyle\geq 2^{-k}\Big{(}1-\frac{k}{N}\Big{)}^{k}\geq 2^{-k}\Big{(}1-\frac{k^{2}}{N}\Big{)}\geq 2^{-k-1}.$$

$$t_{i}=\bigg{\lceil}\frac{4bM_{i}\log(2/\delta)}{\xi^{2}\sum_{\ell}\hat{\mu}_{\ell}}\bigg{\rceil}.$$

$$\sum _{i=1}^q\sum _{j=1}^{t_i}\frac{X_{i,j}}{t_i}\in (1\pm \xi )\sum _{i=1}^q{\mu }_i.$$

$$X=\sum _{i=1}^q\sum _{j=1}^{t_i}\frac{X_{i,j}}{t_i},x=\sum _{i=1}^q{\mu }_i.$$

$$\sum_{i=1}^{q}\sum_{j=1}^{t_{i}}\mathbb{E}\big{(}(X_{i,j}/t_{i})^{2}\big{)}\leq\sum_{i=1}^{q}\sum_{j=1}^{t_{i}}\frac{1}{t_{i}^{2}}\mathbb{E}(M_{i}X_{i,j})=\sum_{i=1}^{q}\frac{M_{i}\mu_{i}}{t_{i}}.$$

$$\mathbb{P}(|X-x|\ge \xi x)$$

$$\displaystyle\leq 2\exp\bigg{(}{-}\frac{3\xi^{2}x^{2}}{2\max\big{\{}6\sum_{i}\frac{M_{i}\mu_{i}}{t_{i}},\ 2M\xi x\big{\}}}\bigg{)}$$

$$\displaystyle=\max\bigg{\{}2\exp\Big{(}{-}\frac{\xi^{2}x^{2}}{4\sum_{i}\frac{M_{i}\mu_{i}}{t_{i}}}\Big{)},\ 2\exp\Big{(}{-}\frac{3\xi x}{4M}\Big{)}\bigg{\}}.$$

$$\frac{\xi^{2}x^{2}}{4\sum_{i}\frac{M_{i}\mu_{i}}{t_{i}}}\geq\xi^{2}x^{2}\Big{/}\bigg{(}4\sum_{i}M_{i}\mu_{i}\cdot\frac{\xi^{2}\sum_{j}\hat{\mu}_{j}}{4bM_{i}\log(2/\delta)}\bigg{)}=\frac{bx^{2}\log(2/\delta)}{\sum_{i}\mu_{i}\cdot\sum_{j}\hat{\mu}_{j}}=\frac{bx\log(2/\delta)}{\sum_{j}\hat{\mu}_{j}}.$$

$$\frac{{\xi }^2{x}^2}{4{\sum }_i\frac{M_i{\mu }_i}{t_i}}\ge \log (2/\delta )\ge \ln (2/\delta ).$$

$$M=\max\Big{\{}\frac{M_{i}}{t_{i}}\colon i\in[q]\Big{\}}\leq\max\Big{\{}\frac{\xi^{2}\sum_{j}\hat{\mu}_{j}}{4b\log(2/\delta)}\colon i\in[q]\Big{\}}\leq\frac{\xi^{2}x}{4\log(2/\delta)},$$

$$\frac{3\xi x}{4M}\ge \frac{3\log (2/\delta )}{\xi }>\ln (2/\delta ).$$

$$Z(L)$$

$$L_i$$

$$t_{i}\leftarrow\Big{\lceil}\frac{16b^{2}2^{i}|L_{i}|\log(2/\delta)}{\xi^{2}W}\Big{\rceil},\mbox{ where }W:=\sum_{(w,S,\hat{e})\in L}w\hat{e}.$$

$$\Omega (k{b}^4\log (\frac{1}{\delta })\log (nb)/{\xi }^2)$$

$$|L^{\prime }|$$

$$=2a+1+\frac{16b^2\log (2/\delta )}{{\xi }^{2}W}\sum _{|i|\le a}{2}^i|L_i|.$$

$$\sum_{|i|\leq a}2^{i}|L_{i}|\leq\sum_{|i|\leq a}\Big{(}2\sum_{(w,S,\hat{e})\in L_{i}}w\hat{e}\Big{)}=2W.$$

$$\mathcal{I}:=\{-a\le i\le a:|L_i|>t_i\};$$

$$X_{i,j}$$

$${\mu }_i$$

$$X_{i,j}\le b{w}_{i,j}{\hat{e}}_{i,j}|L_i|\le 2^{i}b|L_i|=M_i.$$

$$\Big{\lceil}\frac{4bM_{i}\log(2/\delta)}{(\xi/2)^{2}\sum_{\ell}\hat{\mu}_{\ell}}\Big{\rceil}=\Big{\lceil}\frac{16b^{2}2^{i}|L_{i}|\log(2/\delta)}{\xi^{2}W}\Big{\rceil}=t_{i}.$$

$$\sum _{i\in \mathcal{I}}\sum _{j=1}^{t_i}\frac{X_{i,j}}{t_i}\in (1\pm \xi /2)\sum _{i\in \mathcal{I}}{\mu }_i.$$

$$\sum _{i\in \mathcal{I}}\sum _{j=1}^{t_i}\frac{X_{i,j}}{t_i}=\sum _{i\in \mathcal{I}}\sum _{j=1}^{t_i}\frac{w_{i,j}|L_i|}{t_i}e(G[S_{i,j}])=\sum _{i\in \mathcal{I}}\sum _{(w,S,\hat{e})\in L_i^{\prime }}we(G[S]),$$

Full text

Our results have consequences for approximate counting/sampling: We can turn certain kinds of decision algorithms into approximate counting/sampling algorithms without causing much overhead in the running time. We apply this approximate-counting/sampling-to-decision reduction to key problems in fine-grained complexity (such as $k$-SUM, $k$-OV and weighted $k$-Clique) and parameterised complexity (such as induced subgraphs of size $k$ or weight-$k$ solutions to CSPs).

1 Introduction

Many decision problems reduce to the question: Does a witness exist? Such problems admit a natural counting version: How many witnesses exist? For example, one may ask whether a bipartite graph contains a perfect matching, or how many perfect matchings it contains. As one might expect, the counting version is never easier than the decision version, and is often substantially harder; for example, deciding whether a bipartite graph contains a perfect matching is easy, and counting the number of such matchings is #P-complete [47]. However, even when the counting version of a problem is hard, it is often easy to approximate well. For example, Jerrum, Sinclair and Vigoda [36] gave a polynomial-time approximation algorithm for the number of perfect matchings in a bipartite graph. The study of approximate counting has seen amazing progress over the last two decades, particularly in the realm of trichotomy results for general problem frameworks such as constraint satisfaction problems, and is now a major field of study in its own right [21, 22, 29, 32, 33]. In this paper, we explore the question of when approximating the counting version of a problem is not merely fast, but essentially as fast as solving the decision version.

We first recall the standard notion of approximation in the field: For all real $x,y>0$ and $0<\varepsilon<1$, we say that $x$ is an $\varepsilon$-approximation to $y$ if $|x-y|<\varepsilon y$. Note in particular that any $\varepsilon$-approximation to zero is itself zero, so computing an $\varepsilon$-approximation to $N$ is always at least as hard as deciding whether $N>0$ holds. For example, it is at least as hard to approximately count the number of satisfying assignments of a CNF formula (i.e. to $\varepsilon$-approximate #Sat) as it is to decide whether it is satisfiable at all (i.e. to solve Sat).

Perhaps surprisingly, in many cases, the converse is also true. For example, Valiant and Vazirani [48] proved that any polynomial-time algorithm to decide Sat can be bootstrapped into a polynomial-time $\varepsilon$-approximation algorithm for #Sat, or, more formally, that a size-$n$ instance of any problem in #P can be $\varepsilon$-approximated in time $\operatorname{poly}(n,\varepsilon^{-1})$ using an NP-oracle. A similar result holds in the parameterised setting, where Müller [45] proved that a size-$n$ instance of any problem in #W[$i$] with parameter $k$ can be $\varepsilon$-approximated in time $g(k)\cdot\mbox{poly}(n,\varepsilon^{-1})$ using a W[$i$]-oracle for some computable function $g\colon\mathbb{N}\to\mathbb{N}$. Another such result holds in the subexponential setting, where Dell and Lapinskas [17] proved that the (randomised) Exponential Time Hypothesis is equivalent to the statement: There is no $\varepsilon$-approximation algorithm for #3-Sat which runs on an $n$-variable instance in time $\varepsilon^{-2}2^{o(n)}$.

We now consider the fine-grained setting, which is the focus of this paper. Here, we are concerned with the exact running time of an algorithm, rather than broad categories such as polynomial time, FPT time or subexponential time. The above reductions all introduce significant overhead, so they are not fine-grained. Here only one general result is known, again due to Dell and Lapinskas [17]. Informally, if the decision problem reduces “naturally” to deciding whether an $n$-vertex bipartite graph contains an edge, then any algorithm for the decision version can be bootstrapped into an $\varepsilon$-approximation algorithm for the counting version with only $\widetilde{\mathcal{O}}(\varepsilon^{-2})$ overhead. (Here and elsewhere, the $\widetilde{\mathcal{O}}$-notation suppresses a factor of $C\log^{C}n$ for some constant $C>0$ depending only on the problem statement.) See Section 1.1 for more details.

The reduction of [17] is general enough to cover core problems in fine-grained complexity such as Orthogonal Vectors, 3SUM and Negative-Weight Triangle, but it is not universal. In this paper, we substantially generalise it to cover any problem which can be “naturally” formulated as deciding whether a $k$-partite $k$-hypergraph contains an edge; thus we essentially recover the original result on taking $k=2$. For any problem which satisfies this property, our result implies that any new decision algorithm will automatically lead to a new approximate counting algorithm whose running time is at most a factor of $\log^{\mathcal{O}(k)}n$ larger. Our framework covers several reduction targets in fine-grained complexity not covered by [17], including $k$-Orthogonal Vectors, $k$-SUM and Exact-Weight $k$-Clique, as well as some key problems in parameterised complexity including weight-$k$ CSPs and size-$k$ induced subgraph problems. (Note that the overhead of $\log^{\mathcal{O}(k)}n$ can be re-expressed as $k^{2k}n^{o(1)}$ using a standard trick, so an FPT decision algorithm is transformed into an FPT approximate counting algorithm; see Section 1.2.)

In fact, we get more than fast approximate counting algorithms — we also prove that any problem in this framework has an algorithm for approximately-uniform sampling, again with $\log^{\mathcal{O}(k)}n$ overhead over decision. There is a well-known reduction between the two for self-reducible problems due to Jerrum, Valiant and Vazirani [37], but it does not apply in our setting since it adds polynomial overhead.

In the parameterised setting, our results have interesting implications. Here, the requirement that the hypergraph be $k$-partite typically corresponds to considering the “colourful” or “multicolour” version of the decision problem, so our result implies that uncoloured approximate counting is essentially equivalent to multicolour decision. We believe that our results motivate considerable further study of the relationship between multicolour parameterised decision problems and their uncoloured counterparts.

Finally, we note that the applications of our results are not just complexity-theoretic in nature, but also algorithmic. They give a “black box” argument that any decision algorithm in our framework, including fast ones, can be converted into an approximate counting or sampling algorithm with minimal overhead. Concretely, we obtain new algorithms for approximately counting and/or sampling zero-weight subgraphs, graph motifs, and satisfying assignments for first-order models, and our framework is sufficiently general that we believe new applications will be forthcoming.

In Section 1.1, we set out our main results in detail as Sections 1.1 and 1.1, and discuss our edge-counting reduction framework (which is of independent interest). We describe the applications of our main results to fine-grained complexity and parameterised complexity in Section 1.2.

1.1 The $k$-hypergraph framework

Given a $k$-hypergraph $G=(V,E)$, write $e(G)=|E|$, and let

[TABLE]

For any $(X_{1},\ldots,X_{k})\in\mathcal{C}(G)$, we write $G[X_{1},\dots,X_{k}]$ for the $k$-partite $k$-hypergraph on $X_{1}\cup\dots\cup X_{k}$ whose edge set is $\{e\in E(G)\colon|e\cap X_{i}|=1\mbox{ for all }i\in[k]\}$. We define the colourful independence oracle111Arguably, colourful edge oracle would be a more natural name, but we stick to the name established in the literature. of $G$ to be the function $\textup{cIND}_{G}\colon\mathcal{C}(G)\to\{0,1\}$ such that $\textup{cIND}_{G}(X_{1},\dots,X_{k})=1$ if $G[X_{1},\dots,X_{k}]$ has no edges, and $\textup{cIND}_{G}(X_{1},\dots,X_{k})=0$ otherwise. Informally, we think of elements of $\mathcal{C}(G)$ as representing $k$-colourings of induced subgraphs of $G$, with $X_{i}$ being the $i$’th colour class; thus given a vertex colouring of an induced subgraph of $G$, the colourful independence oracle outputs 1 if and only if no colourful edge is present. We consider a computation model where the algorithm is given access to $V$ and $k$, but can only access $E$ via $\textup{cIND}_{G}$. We say that such an algorithm has colourful oracle access to $G$, and for legibility we write it to have $G$ as an input. Note that given colourful oracle access to $G$, it is trivial to simulate the colourful independence oracle of $G[X]$ for any $X\subseteq V(G)$ as in [7]. Our main result is as follows.

Theorem \thetheorem.

There is a randomised algorithm $\textnormal{{Count}}(G,\varepsilon,\delta)$ with the following behaviour. Suppose $G$ is an $n$-vertex $k$-hypergraph, and that Count has colourful oracle access to $G$. Suppose $\varepsilon$ and $\delta$ are rational with $0<\varepsilon,\delta<1$. Then, writing $T=\log(1/\delta)\varepsilon^{-2}k^{6k}\log^{4k+7}n$: in time $\mathcal{O}(nT)$, and using at most $\mathcal{O}(T)$ queries to cINDG*, $\textnormal{{Count}}(G,\varepsilon,\delta)$ outputs a rational number $\hat{e}$. With probability at least $1-\delta$, we have $\hat{e}\in(1\pm\varepsilon)e(G)$. *

As an example of how Section 1.1 applies to approximate counting problems, consider the problem #$k$-Clique of counting the number of size-$k$ cliques in an $n$-vertex graph $H$. We take $G$ to be the $k$-hypergraph on vertex set $V(H)$ whose edges are precisely those size-$k$ sets which span cliques in $G$. Thus, $\varepsilon$-approximating the number of $k$-cliques in $H$ corresponds to $\varepsilon$-approximating the number of edges in $G$. We may use a decision algorithm for $k$-Clique with running time $f(n,k)$ to evaluate $\textup{cIND}_{G}$ in time $f(n,k)$, by applying it to an appropriate subgraph of $G$ (in which we delete all edges within each colour class $X_{i}$). Thus, Section 1.1 gives us an algorithm for $\varepsilon$-approximating the number of $k$-cliques in $H$ in time $\mathcal{O}(nT+Tf(n,k))$. Any decision algorithm for $k$-Clique must read a constant proportion of its input, so we have $f(n,k)=\Omega(n)$ and our overall running time is $\mathcal{O}(Tf(n,k))$. It follows that any decision algorithm for $k$-clique yields an $\varepsilon$-approximation algorithm for #$k$-Clique with overhead only $T=\varepsilon^{-2}(k\log n)^{\mathcal{O}(k)}$.

The polynomial dependence on $\varepsilon$ in Section 1.1 is not surprising, as by taking $\varepsilon<1/2n^{k}$ and rounding we can obtain the number of edges of $G$ exactly. Thus, if the dependence on $\varepsilon$ were subpolynomial, Section 1.1 would essentially imply a fine-grained reduction from exact counting to decision. This is impossible under SETH in our setting; see [17, Theorem 3] for a more detailed discussion.

We extend Section 1.1 to approximately-uniform sampling as follows.

Theorem \thetheorem.

*There is a randomised algorithm $\textnormal{{Sample}}(G,\varepsilon)$ which, given a rational number $\varepsilon$ with $0<\varepsilon<1$ and colourful oracle access to an $n$-vertex $k$-hypergraph $G$ containing at least one edge, outputs either a random edge $f\in E(G)$ or Fail. For all $f\in E(G)$, $\textnormal{{Sample}}(G,\varepsilon)$ outputs $f$ with probability $(1\pm\varepsilon)/e(G)$; in particular, it outputs Fail with probability at most $\varepsilon$. Moreover, writing $T=\varepsilon^{-2}k^{7k}\log^{4k+11}n$, $\textnormal{{Sample}}(G,\varepsilon)$ runs in time $\mathcal{O}(nT)$ and uses at most $\mathcal{O}(T)$ queries to $\textup{cIND}_{G}$. *

We call the output of this algorithm an $\varepsilon$-approximate sample. Note that there is a standard trick using rejection sampling which, given an algorithm of the above form, replaces the $\varepsilon^{-2}$ factor in the running time by a $\widetilde{\mathcal{O}}(\varepsilon^{-1})$ factor; see [37]. Unfortunately, it does not apply to Section 1.1, as we do not have a fast way to compute the true distribution of Sample’s output.

By the same argument as above, Section 1.1 may be used to sample a size-$k$ clique from a distribution with total variation distance at most $\varepsilon$ from uniformity with overhead only $T=\varepsilon^{-2}(k\log n)^{\mathcal{O}(k)}$ over decision. (We also note that it is easy to extend Sections 1.1 and 1.1 to cover the case where the original decision algorithm is randomised, at the cost of an extra factor of $k\log n$ in the number of oracle uses; we discuss this below.)

Sections 1.1 and 1.1 are also of independent interest, generalising known results in the graph oracle literature. Colourful independence oracles are a natural generalisation of the bipartite independent set (BIS) oracles introduced in Beame et al. [7] to a hypergraph setting, and when $k=2$ the two notions coincide. They were first introduced in Bishnu et al. [12] to solve various decision problems in parameterised complexity. The main result of Beame et al. [7, Theorem 4.9] says that given BIS oracle access to an $n$-vertex graph $G$, one can $\varepsilon$-approximate the number of edges of $G$ using $\mathcal{O}(\varepsilon^{-4}\log^{14}n)$ BIS queries (which they take as their measure of running time). The $k=2$ case of Sections 1.1 and 1.1 give a total of $\mathcal{O}(\varepsilon^{-2}\log^{19}n)$ queries used, improving their running time for most values of $\varepsilon$, and extending their algorithm to approximately-uniform sampling.

When $k=3$, our colourful independence oracles are similar to the tripartite independent set (TIS) oracles of Bhattacharya et al. [10]. (These oracles ask whether a 3-coloured graph $H$ contains a colourful triangle, rather than whether a 3-coloured 3-hypergraph $G$ contains a colourful edge. But if $G$ is taken to be the 3-hypergraph whose edges are the triangles of $H$, then the two notions coincide exactly.) Their main result, Theorem 1, says that given TIS oracle access to an $n$-vertex graph $G$ in which every edge belongs to at most $d$ triangles, one can $\varepsilon$-approximate the number of triangles in $G$ using at most $\mathcal{O}(\varepsilon^{-12}d^{12}\log^{25}n)$ TIS queries; they have subsequently [11] improved this to $\mathcal{O}(\varepsilon^{-4}d^{2}\log^{18}n)$. Our Section 1.1 gives an algorithm which requires only $\mathcal{O}(\varepsilon^{-2}\log^{19}n)$ TIS queries, with no dependence on $d$, and which also generalises to approximately counting $k$-cliques for all fixed $k$. Again, Section 1.1 extends the result to approximately-uniform sampling.

In an independent work made public shortly after this paper appeared on arXiv, Bhattacharya et al. [9] also prove a version of Section 1.1 (but not Section 1.1) for arbitrary $k$. Their generalised $d$-partite independent set oracles are essentially the same as our independence oracles, and their algorithm makes $\mathcal{O}(\varepsilon^{-4}\log^{5k+5}n)$ queries on an $n$-vertex $k$-uniform input hypergraph; for comparison, our algorithm makes $\mathcal{O}(\varepsilon^{-2}\log^{4k+7}n)$ queries. Our algorithm therefore trades a slightly worse dependence on $n$ for a significantly better dependence on $\varepsilon$. As in [10], the authors are motivated by the theory of graph oracles rather than by applications to specific approximation algorithms.

We note in passing that the main result of [17] doesn’t quite fit into this setting, as it also makes unrestricted use of edge existence queries. It resembles a version of Section 1.1 restricted to $k=2$ and with slightly lower overhead in $n$.

If the colourful independence oracle $\textup{cIND}_{G}$ of a $k$-hypergraph $G$ can be simulated by a deterministic algorithm $A_{G}$, then Sections 1.1 and 1.1 immediately yield algorithms for approximately counting and sampling edges of $G$: Whenever the algorithms in Sections 1.1 and 1.1 would query $\textup{cIND}_{G}$, they instead run $A_{G}$ as a black-box. Suppose instead $A_{G}$ is a randomised algorithm whose error probability is bounded by a constant, say $1/3$. Then we can use standard probability amplification techniques to make sure that, during any execution of the algorithms in Sections 1.1 and 1.1, it is very likely that all queries to $\textup{cIND}_{G}$ are answered correctly. For convenience, we encapsulate this argument in the following corollary. We defer the (simple) proof to Section 6.

Corollary \thetheorem.

There is a randomised algorithm SampleCount with the following behaviour. Let $G$ be an arbitrary $n$-vertex $k$-hypergraph for some $n$ and $k$, and let $A_{G}$ be a randomised implementation of the colourful independence oracle of $G$ with worst-case running time $T$ and error probability at most $1/3$. Let $\varepsilon,\delta>0$. Then SampleCount $(V(G),k,A_{G},\varepsilon,\delta)$ outputs an $\varepsilon$-approximation of $e(G)$ with error probability at most $\delta$ and an $\varepsilon$-approximate sample from $E(G)$ with error probability zero. Moreover, the running time of SampleCount is at most

[TABLE]

We remark that the worst-case running time of $A_{G}$ is measured as the maximum possible running time of executions $A_{G}(X_{1},\dots,X_{k})$ over all internal random choices of $A_{G}$ and inputs $X_{1},\dots,X_{k}$. We also mention an analogous corollary for approximately counting and sampling edges of any $k$-partite hypergraph $G[X_{1},\dots,X_{k}]$ even if $G$ is not $k$-partite itself; note that we do not require $X_{1}\cup\dots\cup X_{k}=V(G)$.

In the case where the hypergraph $G$ is $k$-partite, we can make do with a weaker form of the oracle. Given a $k$-hypergraph $G=(V,E)$, we define the uncoloured independence oracle of $G$ to be the function $\mathrm{IND}_{G}\colon 2^{V}\to\{0,1\}$ such that $\mathrm{IND}_{G}(X)=1$ if $G[X]$ contains no edges, and $\mathrm{IND}_{G}(X)=0$ otherwise. As we show in Section 6, on a $k$-partite graph it is not hard to simulate $\textup{cIND}_{G}$ given access to $\mathrm{IND}_{G}$.

Corollary \thetheorem.

There is a randomised algorithm PartitionedSampleCount with the following behaviour. Let $G$ be an arbitrary $n$-vertex $k$-partite $k$-hypergraph for some $n$ and $k$ with vertex classes $V_{1},\dots,V_{k}$, and let $A_{G}$ be a randomised implementation of the uncoloured independence oracle of $G$ with worst-case running time $T$ and error probability at most $1/3$. Let $\varepsilon,\delta>0$. Then PartitionedSampleCount $(V_{1},\dots,V_{k},k,A_{G},\varepsilon,\delta)$ outputs an $\varepsilon$-approximation of $e(G)$ with failure probability at most $\delta$ and an $\varepsilon$-approximate sample from $E(G)$ with error probability zero. The running time of PartitionedSampleCount is at most ${\varepsilon^{-2}\log^{2}(1/\delta)(k\log n)^{\mathcal{O}(k)}(n+T)}$. *

1.2 Applications

Sections 1.1 and 1.1 have algorithmic implications for many well-known problems in fine-grained and parameterised complexity. On a formal level, there is no reason not to simply apply Sections 1.1 and 1.1. However, it is instructive to tie these corollaries back to the standard informal notion of the “colourful version” of a problem, which we do in the following pair of definitions. Recall that a counting problem is a function $\#\Pi\colon\{0,1\}^{\ast}\to\mathbb{N}$ and its corresponding decision problem is defined via ${\Pi=\{x\in\{0,1\}^{\ast}\colon\#\Pi(x)>0\}}$.

Definition 1.1**.**

$\Pi$* is a uniform witness problem if there is a function from instances $x\in\{0,1\}^{\ast}$ to uniform hypergraphs $G_{x}$ such that:*

1. (i)

$\#\Pi(x)=e(G_{x})$; 2. (ii)

$V(G_{x})$* and the size of edges in $E(G_{x})$ can be computed from $x$ in time $\widetilde{\mathcal{O}}(|x|)$;* 3. (iii)

there exists an algorithm which, given $x$ and $S\subseteq V(G_{x})$, in time $\widetilde{\mathcal{O}}(|x|)$ prepares an instance $I_{x}(S)$ of $\Pi$ such that $G_{I_{x}(S)}=G_{x}[S]$ and $|I_{x}(S)|\in\mathcal{O}(|x|)$.

*We say $\Pi$ is a colourful uniform witness problem if $G_{x}$ is always $k$-partite, where $k$ is the edge size of $G_{x}$. The set $E(G_{x})$ is the set of witnesses of the instance $x$. *

For all the problems we consider, there will only be a single natural choice of hypergraph representation, and so we consider this representation to be a part of the problem statement. For example, $k$-Clique is a uniform witness problem in which for a given instance $x=(H,k)$, $G_{x}$ is the hypergraph on $V(H)$ whose edges are the $k$-cliques of $H$. It is immediate that Definition 1.1(i) and (ii) are satisfied, and Definition 1.1(iii) is satisfied because “induced subgraphs of $G_{x}$ correspond to sub-instances of $x$” — that is, for a given instance $x=(H,k)$ of $k$-Clique and a given $S\subseteq V(G_{x})=V(H)$, $I_{x}(S)$ is the instance $(H[S],k)$. As a second example, Orthogonal Vectors is a colourful uniform witness problem in which the witnesses are pairs of orthogonal vectors from the given input sets, and again induced subgraphs of $G_{x}$ correspond to sub-instances of $x$.

Definition 1.2**.**

*Suppose $\Pi$ is a uniform witness problem. Colourful-$\Pi$ is defined as the problem of, given an instance $x\in\{0,1\}^{\ast}$ of $\Pi$ and a partition of $V(G_{x})$ into disjoint sets $S_{1},\dots,S_{k}$, deciding whether $\text{cIND}_{G_{x}}(S_{1},\dots,S_{k})=0$ holds. *

In other words, in Colourful-$\Pi$, the goal is to decide whether $G_{x}[S_{1},\dots,S_{k}]$ has at least one edge containing one vertex from each colour class $S_{i}$. For example, in Colourful-$k$-Clique, we are given a graph $G$, an integer $k$, and a $k$-colouring of $G$, and wish to know whether $G$ contains a $k$-clique with one vertex of each colour. Observe that if $\Pi$ is already colourful as in Definition 1.1, then Colourful-$\Pi$ reduces to $k^{O(k)}$ instances of $\Pi$, since any colourful edges must respect the existing vertex classes of $G_{x}$ and since induced subgraphs of $G_{x}$ correspond to instances of $\Pi$. The colourful version of a problem is sometimes referred to as the multicolour version [43].

Given an instance of $\Pi$, we write $n_{x}$ for the number of vertices of $G_{x}$, $k_{x}$ for the edge size of $G_{x}$, and $W_{x}$ for the set of witnesses of $x$. Using this terminology, we can now restate (a slightly simplified form of) Sections 1.1 and 1.1 as follows, where we use part (iii) of Definition 1.1 to ensure that $\mbox{cIND}_{G_{x}}(S_{1},\dots,S_{k})$ can be computed efficiently even when $S_{1}\cup\dots\cup S_{k}\subsetneq V(G_{x})$. We prove this result in section 6.

Theorem 1.3**.**

Let $\Pi$ be a uniform witness problem, and let $T$ be any function from instances of $\Pi$ to the positive reals. Suppose that given an instance $x$ of $\Pi$, there is an algorithm to solve Colourful-$\Pi$ on $x$ with error probability at most $1/3$ in time $T(x)$. Suppose also that any such algorithm has running time $\widetilde{\Omega}(|x|)$. Then there is a randomised algorithm which, given an instance $x$ of $\Pi$ and $\varepsilon>0$, with running time

[TABLE]

*outputs an $\varepsilon$-approximation to $\#\Pi(x)$ with probability at least $2/3$ and an $\varepsilon$-approximate sample from $W_{x}$ with error probability zero. *

In a typical application of Theorem 1.3, the maximum in (1) will be $\widetilde{\mathcal{O}}(T(x))$. Recall that if $\Pi$ is already colourful, then Colourful-$\Pi$ reduces to $k^{O(k)}$ instances of $\Pi$, so Theorem 1.3 can be used to reduce from colourful approximate counting to colourful decision as well as from uncoloured approximate counting to colourful decision.

One large family of problems to which this meta-theorem can naturally be applied is that of self-contained $k$-witness problems (see [44]); these are essentially a form of uniform witness problems $\Pi$ in which for any instance $x$ of $\Pi$ and all $S\subseteq V(G_{x})$, the instance $I_{x}(S)$ is a sub-instance of $x$ in a well-defined sense. Thus, every self-contained $k$-witness problem is a uniform witness problem, but it seems likely that not every uniform witness problem is a self-contained $k$-witness problem.

Applications in fine-grained complexity

In the fine-grained setting, $k$ is considered to be a fixed constant, so the running-time bound in Theorem 1.3 can be written as $\widetilde{\mathcal{O}}(\varepsilon^{-2}\cdot T(n,k))$.

In [17], fine-grained reductions from approximate counting to decision were shown for the problems Orthogonal Vectors, 3SUM, and Negative-Weight Triangle. In Section 6, we generalise these reductions to $k$-Orthogonal Vectors, $k$-SUM, Zero-Weight $k$-Clique, and other subgraph isomorphism problems, such as Colourful-$H$, Exact-Weight $k$-Clique, and Exact-Weight $H$. Similarly, we also reduce approximate model counting to model checking with respect to $k$-variable first-order formulas. In each case, we also have a corresponding result for approximate sampling of witnesses.

We prove these results in Section 6 as a corollary of our main results. To do so, we observe that these problems are natural $k$-witness problems, and that any decision algorithm for each of these problems can be coaxed in a more or less standard way to also solve the colourful variant of the problem in roughly the same time.

Applications in parameterised complexity

In the parameterised setting, we assume that $k$ is taken as the parameter and are therefore interested in the running time of our algorithms as a function of $k$. We note that our reduction from approximate counting to decision involves only a “fine-grained FPT overhead”: we can rewrite the overhead of $\log^{\mathcal{O}(k)}n$ as an overhead of $k^{2k}n^{o(1)}$ by a standard calculation.222Indeed, if $k\leq\log n/(\log\log n)^{2}$ then $\log^{\mathcal{O}(k)}n=e^{\mathcal{O}(\log n/\log\log n)}=n^{o(1)}$, and if $k\geq\log n/(\log\log n)^{2}$ then $\log^{\mathcal{O}(k)}n=\mathcal{O}(k^{2k})$. Thus, whenever there is an FPT implementation of the colourful independence oracle, Theorem 1.3 gives us an FPTRAS (fixed parameter tractable randomised approximation scheme [6]) for the corresponding (colourful or uncoloured) counting problem. For the formal definition of an FPTRAS, and other standard notions in parameterised (counting) complexity, we refer the reader to [26].

The family of uniform witness problems from Definition 1.1 includes numerous problems in parameterised complexity, including weight-$k$ solutions to CSPs, size-$k$ solutions to database queries, and sets of $k$ vertices in a weighted or unweighted graph or hypergraph which induce a sub(hyper)graph with specific properties. We present three concrete applications of Theorem 1.3.

Our first application of Theorem 1.3 is to the Graph Motif problem, introduced by Lacroix, Fernandes and Sagot [40] in the practical context of metabolic networks. While we defer a detailed discussion to Section 6.1, it will be immediate from the definition that Graph Motif is a uniform witness problem, and that Colourful-Graph Motif reduces to Graph Motif (see Lemma 6.6); hence Theorem 1.3 combined with the best-known algorithm for Graph Motif yields an improved approximate counting algorithm (see Corollary 6.5).

Our second application of Theorem 1.3 is to induced subgraph counting. Many problems in this area are special cases of Induced Subgraph With Property ($\Phi$), abbreviated to ISWP($\Phi$). This problem asks whether a given graph $G$ contains a $k$-vertex induced subgraph with the given property $\Phi$; the problem is then parameterised by $k$. For example, if $\Phi$ is the family of all cliques, then ISWP($\Phi$) is simply $k$-Clique. There is also a multi-coloured variant of the problem, MISWP($\Phi$), in which every vertex in $G$ receives one of $k$ colours, and we seek a $k$-vertex induced subgraph with property $\Phi$ and one vertex of each colour. See [43] for a survey of results on exact and approximate #ISWP($\Phi$) and #MISWP($\Phi$), and [27] for a more recent complexity classification of #ISWP($\Phi$) whenever $\Phi$ is a hereditary property. Observe that ISWP is a uniform witness problem, where the witnesses are the $k$-vertex subsets of $V(G)$ which induce copies of graphs satisfying $\Phi$, and Colourful-ISWP($\Phi$) is simply MISWP($\Phi$); hence Theorem 1.3 immediately implies that there is an FPTRAS for #MISWP($\Phi$) and #ISWP($\Phi$) whenever there is an FPT decision algorithm for MISWP($\Phi$), and moreover that the running times of these algorithms are the same up to a sub-polynomial factor in the instance size. This improves on the best previously-known result (due to Meeks [44, Corollaries 4.8 and 4.10]) in two ways: firstly, in [44] the result is proved only for properties $\Phi$ that are preserved under adding edges; and secondly, in [44] the FPTRAS is slower than the FPT decision algorithm by a polynomial factor.

Our third application of Theorem 1.3 is to the problems Colourful-$H$ and Weighted-$H$ for a given $k$-vertex graph $H$. In Colourful-$H$, we are given a graph $G$ whose vertices are coloured with $k$ colours, and we wish to decide whether $G$ contains a subgraph copy of $H$ in which every colour is represented. In Weighted-$H$, we are given an edge-weighted graph $G$, and we wish to decide whether $G$ contains a subgraph copy of $H$ with total weight zero. Unlike our other two applications, the application of Theorem 1.3 in this setting is not straightforward. The natural way to frame these problems as uniform witness problems would be, as with ISWP, to take the witnesses to be vertex sets which induce a copy of $H$; however, the number of witnesses would then not in general agree with the number of colourful or zero-weighted copies of $H$ as required by Definition 1.1(i). Nevertheless, we are able to use Theorem 1.3 to give a fine-grained reduction from approximate #Colourful-$H$ to Colourful-$H$ and from approximate #Weighted-$H$ to Weighted-$H$ for all graphs $H$; see Corollary 6.14 and Corollary 6.18 for details.

One reason this third application is interesting is that it throws an existing research question into a new light. In Uncoloured-$H$, we are given a graph $G$, and we wish to decide whether $G$ contains a subgraph copy of $H$. There are easy and well-known fine-grained reductions from Uncoloured-$H$ to Colourful-$H$ and from approximate #Uncoloured-$H$ to approximate #Colourful-$H$, via colour coding [5, 4]. For some graphs $H$, such as cliques, there are also simple reductions in the other direction. However, a full proof of equivalence would imply the long-standing dichotomy conjecture for the parameterised embedding problem (see [16] for recent progress on this conjecture). Corollary 6.14 shows that this question is strongly linked to the question of when there is a fine-grained FPT reduction from Colourful-$H$ to Uncoloured-$H$, and we hope this will spur further research in the area.

Organisation. In the following section, we set out our notation and quote some standard probabilistic results for future reference. We then prove Section 1.1 in Section 3.2, using a weaker approximation algorithm which we set out in Section 4. We then prove Section 1.1 (using Section 1.1) in Section 5. Finally, we prove our assorted corollaries in Section 6; we emphasise that in general, the proofs in this section are easy and use only standard techniques.

2 Preliminaries

2.1 Notation

Let $k\geq 2$ and let $G=(V,E)$ be a $k$-hypergraph, so that each edge in $E$ has size exactly $k$. We write $e(G)=|E|$. For all $U\subseteq V$, we write $G[U]$ for the subgraph induced by $U$. For all $S\subseteq V$, we write $d_{G}(S)=|\{e\in E(G)\colon S\subseteq e\}|$ for the degree of $S$ in $G$. If $S=\{v_{1},\dots,v_{|S|}\}$, then we will sometimes write $d_{G}(v_{1},\dots,v_{|S|})=d_{G}(S)$.

For all positive integers $t$, we write $[t]=\{1,\dots,t\}$. We write $\ln$ for the natural logarithm, and $\log$ for the base-2 logarithm. Given real numbers $x,y\geq 0$ and $0<\varepsilon<1$, we say that $x$ is an $\varepsilon$-approximation to $y$ if $(1-\varepsilon)x<y<(1+\varepsilon)x$, and write $y\in(1\pm\varepsilon)x$. We extend this notation to other operations in the natural way, so that (for example) $y\in xe^{\pm\varepsilon}/(2\mp\varepsilon)$ means that $xe^{-\varepsilon}/(2+\varepsilon)\leq y\leq xe^{\varepsilon}/(2-\varepsilon)$.

When stating quantitative bounds on running times of algorithms, we assume the standard randomised word-RAM machine model with logarithmic-sized words; thus given an input of size $N$, we can perform arithmetic operations on $\mathcal{O}(\log N)$-bit words and generate uniformly random $\mathcal{O}(\log N)$-bit words in $\mathcal{O}(1)$ time.

Recall the definitions of $\mathcal{C}(G)$ and the colourful independence oracle of $G$, and colourful oracle access from Section 1.1. Note that for all $X\subseteq V(G)$, $\textup{cIND}_{G[X]}$ is a restriction of cINDG. Thus, an algorithm with colourful oracle access to $G$ can safely call a subroutine that requires colourful oracle access to $G[X]$.

2.2 Probabilistic results

We use some standard results from probability theory, which we collate here for reference. The following lemma is commonly known as Hoeffding’s inequality.

Lemma 2.1** ([14, Theorem 2.8]).**

Let $X_{1},\dots,X_{m}$ be independent real random variables, and suppose there exist $a_{1},\dots,a_{m},b_{1},\dots,b_{m}\in\mathbb{R}$ be such that $X_{i}\in[a_{i},b_{i}]$ with probability 1. Let $X=\sum_{i=1}^{m}X_{i}$. Then for all $t\geq 0$, we have

[TABLE]

The next lemma is a form of Bernstein’s inequality.

Lemma 2.2**.**

Let $X_{1},\dots,X_{k}$ be independent real random variables. Suppose there exist $\nu$ and $M$ such that with probability 1, $\sum_{i}\mathbb{E}(X_{i}^{2})\leq\nu$ and $|X_{i}|\leq M$ for all $i\in[k]$. Let $X=\sum_{i=1}^{k}X_{i}$. Then for all $z\geq 0$, we have

[TABLE]

Proof 2.3**.**

*Apply [14, Corollary 2.11] to both $X$ and ${-}X$, taking $c=M/3$ and $t=z$, then apply a union bound. *

The next lemma collates two standard Chernoff bounds.

Lemma 2.4** ([34, Corollaries 2.3-2.4]).**

Suppose $X$ is a binomial or hypergeometric random variable with mean $\mu$. Then:

1. (i)

for all $0<\varepsilon\leq 3/2$, $\mathbb{P}(|X-\mu|\geq\varepsilon\mu)\leq 2e^{-\varepsilon^{2}\mu/3}$; 2. (ii)

for all $t\geq 7\mu$, $\mathbb{P}(X\geq t)\leq e^{-t}$.

The next lemma is a standard algebraic bound.

Lemma 2.5**.**

*Let $N,k\in\mathbb{Z}_{>0}$. If $N\geq 2k^{2}$, then $\binom{2N-k}{N-k}/\binom{2N}{N}\geq 2^{-k-1}$. *

Proof 2.6**.**

We have

[TABLE]

We now prove a technical lemma, which should be read as follows. We are given the ability to sample from bounded probability distributions $\mathcal{D}_{1},\dots,\mathcal{D}_{q}$ on $[0,\infty)$. We wish to estimate the sum of their means using as few samples as possible, and we are given access to a crude estimate of the mean of each $\mathcal{D}_{i}$ with multiplicative error $b$ (for “bias”). Lemma 2.7 says that we can do so to within relative error $\xi$, with failure probability at most $\delta$, by sampling $t_{i}$ times from $\mathcal{D}_{i}$ for each $i\in[q]$. This lemma will be important for reducing the running time of our algorithm; see the sketch proof in section 3.1 for more details.

Lemma 2.7**.**

Let $0<\xi,\delta<1$, let $b\geq 1$, and let $M_{1},\dots,M_{q}>0$. For all $i\in[q]$, let $\mathcal{D}_{i}$ be a probability distribution on $[0,M_{i}]$ with mean $\mu_{i}$. For all $i\in[q]$, let $\hat{\mu}_{i}$ satisfy $0<\hat{\mu}_{i}\leq\mu_{i}b$, and let

[TABLE]

Let $\{X_{i,j}\colon i\in[q],j\in[t_{i}]\}$ be independent random variables with $X_{i,j}\sim\mathcal{D}_{i}$. Then with probability at least $1-\delta$,

[TABLE]

Note that while Lemma 2.7 does not require a lower bound on $\hat{\mu}_{1},\dots,\hat{\mu}_{q}$, without one it is useless as $\sum_{i}t_{i}$ may be arbitrarily large. When we apply Lemma 2.7, we will do so with $\mu_{i}/b\leq\hat{\mu}_{i}\leq\mu_{i}b$ for all $i\in[q]$.

Proof 2.8**.**

We will apply a form of Bernstein’s inequality (Lemma 2.2). Let

[TABLE]

Thus, we seek to prove $\mathbb{P}(X\in(1\pm\xi)x)\geq 1-\delta$. Note that $\mathbb{E}(X)=x$, and that

[TABLE]

Let $M=\max\{M_{i}/t_{i}\colon i\in[q]\}$, so that $X_{i,j}/t_{i}\leq M$ for all $i,j$. Then by Lemma 2.2, applied to the variables $X$ and $X_{i,j}/t_{i}$ with $z=\xi x$, it follows that

[TABLE]

We now bound the exponents of each term in the max. By our choice of $t_{i}$’s, we have

[TABLE]

Since $\hat{\mu}_{i}\leq\mu_{i}b$ for all $i$, we have $x\geq\sum_{j}\hat{\mu}_{j}/b$, so

[TABLE]

Moreover, again by our choice of $t_{i}$’s we have

[TABLE]

so

[TABLE]

*The result therefore follows from (2), (3) and (4). *

3 The main algorithm

In this section we prove our main approximate counting result, Section 1.1. We will make use of an algorithm with a weaker approximation guarantee, whose properties are stated in Lemma 3.4; we will prove this lemma in Section 4.

3.1 Sketch proof

Let $G$ be the input $n$-vertex $k$-hypergraph and let $\varepsilon$ be the input error tolerance, so that we wish to find an $\varepsilon$-approximation of $e(G)$. The overall aim of our algorithm is to iteratively construct a list $L$ of random induced sub-hypergraphs $G[X_{1}],\dots,G[X_{t}]$, together with associated weights $w_{1},\dots,w_{t}$, such that with high probability:

1. (A1)

$\sum_{i}w_{i}\cdot e(G[X_{i}])$ is an $\varepsilon$-approximation to the total number of edges in $G$; and 2. (A2)

each sub-hypergraph $G[X_{i}]$ has few enough edges so that we can efficiently compute $e(G[X_{i}])$ exactly by brute force using the coloured independence oracle; and 3. (A3)

the list $L$ is short enough so that its length does not significantly affect the running time.

Once a list $L$ satisfying (A1)–(A3) is constructed, we can efficiently approximate $e(G)$ by computing each $e(G[X_{i}])$ using (A2) and taking the weighted sum $\sum_{i}w_{i}e(G[X_{i}])$.

Constructing the list $L$

We represent $L$ as a list of pairs $(w_{i},X_{i})$. Initially $L$ contains the single pair $(1,V(G))$, which naturally satisfies (A1). In order to make progress towards a list satisfying (A2) and (A3), we repeatedly modify it in two ways:

1. Refine:

To make the sub-hypergraphs smaller, we replace each hypergraph $G[X]$ in the list $L$ by several random sub-hypergraphs $G[X_{i}]$ induced by half of the vertices of $X$. That is, each pair $(w,X)$ is replaced by $(w_{1},X_{1}),\allowbreak\dots,(w_{t},X_{t})$ where $|X_{i}|=|X|/2$ holds for all $i$. The weights $w_{i}$ are set to maintain (A1) in expectation. This step gets us closer to achieving (A2) and farther from achieving (A3) while maintaining (A1). 2. Reduce:

To make the list $L$ shorter, we discard randomly-selected elements from it and re-weight the remaining elements to maintain (A1) in expectation. This step gets us closer to achieving (A3) while maintaining (A1) and (A2).

We alternate between applying Refine and Reduce to the list until all of (A1)–(A3) are satisfied, at which point we compute and return $\sum_{i}w_{i}e(G[X_{i}])$.

The overall structure of our algorithm for Section 1.1 is very similar to that of Beame et al. [7]. The Cleanup step of [7] roughly corresponds to the calculation of the weighted sum at the end, and is similar. However, our implementation of Refine and Reduce differs in two major ways. Firstly, a key component of both Refine and Reduce is the ability to compute a coarse estimate of the number of edges in each graph $G[X]$, with multiplicative error $\log^{\Theta(k)}n$, and the technique for this used in [7] does not generalise easily to hypergraphs. We provide such an algorithm as Coarse and state its properties as Lemma 3.4, but we defer both the sketch proof and the full proof of this lemma to Section 4. Secondly, by better incorporating these estimates into Refine and Reduce, we improve the running time’s dependence on $\varepsilon$ from $\varepsilon^{-4}$ to $\varepsilon^{-2}$. In order to expand on these differences, we now sketch our implementation of Refine and Reduce given Coarse.

Sketch of Reduce

Suppose we have a long list $L$ of pairs $(w,X)$ satisfying (A1), and we wish to make it shorter by randomly discarding and re-weighting elements while maintaining (A1). (In fact, we start by maintaining something a little stronger than (A1) since the quality of approximation will degrade as the algorithm runs, but we ignore this subtlety in our sketch.) We do this by exploiting a statistical technique called importance sampling, previously applied to the $k=2$ case by Beame et al. [7]. The idea is to use the coarse estimates of each $e(G[X])$ given by Coarse to divide the pairs $(w,X)\in L$ into “bins”, with one bin for pairs with $we(G[X])\in[1,2)$, one bin for pairs with $we(G[X])\in[2,4)$, one bin for pairs with $we(G[X])\in[4,8)$, and so on for a total of $\mathcal{O}(k\log n)$ bins. We then choose a suitably large $t$ and sample $t$ pairs from each bin uniformly at random (or take the whole bin if it contains less than $t$ pairs), then re-weight each element to ensure that (A1) is maintained in expectation; we can then prove concentration via e.g. Hoeffding’s inequality (Lemma 2.1) to conclude that (A1) is maintained with high probability.

The larger we take $t$ to be in Reduce, the fewer pairs we can discard from $L$; thus to minimise our running time, we should take $t$ to be as small as possible while still being able to apply Hoeffding’s inequality, and this is essentially the approach of [7]. The key difference in our approach is that we make use of Lemma 2.7, allowing $t$ to vary between bins. If our estimates from Coarse say that pairs $(w,X)$ in some bin account for about half of the quantity $\sum_{(w,X)\in L}we(G[X])$ we wish to preserve, then we will take about half our samples from that bin, and correspondingly fewer from the other bins. This allows our algorithm for Reduce to maintain a substantially shorter list than the algorithm used in [7], and this is one of the two reasons for our improved running time.

Sketch of Refine

In [7], Refine was implemented by keeping the number of vertices the same but halving the number of edges using random colourings. Our implementation is different and works as follows. Suppose we have a list $L$ of pairs $(w,X)$ satisfying (A1), and we wish to halve the size of all sets $X$ while maintaining (A1). Then for each $X$ and any integer $t\geq 1$, we independently choose $t$ uniformly random subsets $X_{1},\dots,X_{t}\subseteq X$ subject to $|X_{i}|=|X|/2$ for all $i$. It is not hard to show using Lemma 2.5 that $\mathbb{E}(e(G[X_{i}]))\approx e(G)/2^{k}$ holds for all $i$. Thus, using Hoeffding’s inequality for large enough $t$, we can show that the total number of edges $\sum_{i=1}^{t}e(G[X_{i}])$ is concentrated around its mean of roughly $te(G)/2^{k}$. With high probability, we now have $(2^{k}/t)\sum_{i=1}^{t}e(G[X_{i}])\approx e(G)$, so that replacing $(w,X)$ with $\{(2^{k}w/t,X_{i})\colon i\in[t]\}$ maintains (A1). Similarly to Reduce, we use Lemma 2.7 along with our estimates from Coarse to tailor the value of $t$ to each pair $(w,X)\in L$ and avoid making the list too long in a single iteration of Refine, and this is the second reason for our improved running time.

Organisation

The remainder of this section is organised as follows. We begin by setting out the precise format of our list $L$ in Definition 3.1, which (unlike our sketch) also stores the estimates of edge counts from Coarse. We then state the pruning algorithm Reduce and prove its correctness in Lemma 3.2. After this, we state the behaviour we expect from our coarse counting subroutine Coarse in Lemma 3.4 (deferring the proof to Section 4), state the expansion algorithm Refine using Coarse as a subroutine, and prove its correctness in Lemma 3.5. We then state HelperCount, which is essentially our main algorithm, and prove its correctness in Lemma 3.7. Finally, we prove Section 1.1. The purpose of HelperCount is to move some uninteresting bookkeeping details out of the main proof for readability; namely, the differences between HelperCount and Count are that HelperCount requires the number of vertices $n$ to be a power of 2, has a constant failure probability (rather than $\delta$), and could (with vanishing probability) run more slowly than expected.

3.2 The main algorithm

Recall from our sketch proof in Section 3.1 that our algorithm will maintain a weighted list $L$ of induced subgraphs of steadily decreasing size. For convenience, we will also include coarse estimates of the edge count of each graph in $L$. Rather than set out the format of this list each time we use it, we define it formally now.

Definition 3.1**.**

Let $G$ be a hypergraph, let $i>0$ be an integer, and let $b\geq 1$ be rational. Then a $(G,b,y)$-list is a list of triples $(w,S,\hat{e})$ such that $w$ and $\hat{e}$ are positive rational numbers, $S\subseteq V(G)$ with $|S|=2^{y}$, and $\hat{e}/b\leq e(G[S])\leq\hat{e}b$. For any $(G,b,y)$-list $L$, we define

[TABLE]

Initially, we will take $L=((1,V(G),\hat{e}))$ where $\hat{e}/b\leq e(G)\leq\hat{e}b$, so that $Z(L)=e(G)$. As the algorithm progresses, $Z(L)$ will remain a good approximation to $e(G)$, and eventually we will be able to compute it efficiently. We are now ready to set out our importance sampling algorithm, Reduce, which we will use to keep the length of $L$ small.

Algorithm $\textnormal{{Reduce}}(G,b,y,L,\xi,\delta)$.

Input: $G$ is an $n$-vertex $k$-hypergraph, where $n$ is a power of 2, to which Reduce has (only) colourful oracle access. $b$ is a rational number with $b\geq 1$, and $y$ is a positive integer. $L$ is a $(G,b,y)$-list with $1/2\leq Z(L)\leq 2n^{k}$ and $|L|\leq n^{11k}$. $\delta$ is a rational number with $0<\delta<1$, and $\xi$ is a rational number with $n^{-2k}\leq\xi<1$.

Behaviour: $\textnormal{{Reduce}}(G,b,y,L,\xi,\delta)$ outputs a $(G,b,y)$-list $L^{\prime}$ satisfying the following properties.

1. (a)

$|L^{\prime}|\leq 33k\log(4nb)+32b^{2}\log(2/\delta)/\xi^{2}$. 2. (b)

With probability at least $1-\delta$, we have $Z(L^{\prime})\in(1\pm\xi)Z(L)$.

1. (T1)

Calculate $a\leftarrow\lfloor 15k\log(4nb)\rfloor+1$ and

[TABLE]

(We will show that every significant entry of $L$ will be contained in exactly one $L_{i}$, and entries $(w,S,\hat{e})\in L_{i}$ satisfy $w\hat{e}\approx 2^{i}$.) 2. (T2)

For each ${-}a\leq i\leq a$, calculate

[TABLE] 3. (T3)

For each ${-}a\leq i\leq a$, calculate a multiset $L_{i}^{\prime}$ as follows. If $|L_{i}|\leq t_{i}$, let $L_{i}^{\prime}\leftarrow L_{i}$. Otherwise, sample $t_{i}$ entries $(w_{i,1},S_{i,1},\hat{e}_{i,1}),\allowbreak\dots,(w_{i,t_{i}},S_{i,t_{i}},\hat{e}_{i,t_{i}})$ from $L_{i}$ independently and uniformly at random, let $w_{i,j}^{\prime}\leftarrow w_{i,j}|L_{i}|/t_{i}$, and let $L_{i}^{\prime}\leftarrow\{(w_{i,j}^{\prime},S_{i,j},\hat{e}_{i,j})\colon j\in[t_{i}]\}$. 4. (T4)

Form $L^{\prime}$ by concatenating the multisets $\{L_{i}^{\prime}\colon{-}a\leq i\leq a\}$ in an arbitrary order, and return $L^{\prime}$.

The algorithm Reduce improves significantly on the summation reduction algorithm of [7, Lemma 2.5], which in our notation outputs a list of length

[TABLE]

compared to our length of $O(k\log(nb)+b^{2}\log(\tfrac{1}{\delta})/\xi^{2})$. We obtain this improvement by defining the number $t_{i}$ of elements to sample from each “bin” $L_{i}$ of tuples in creating $L_{i}^{\prime}$ to depend on the approximate value $w\hat{e}\approx 2^{i}$ of tuples in $L_{i}$. By contrast, [7, Lemma 2.5] defined a single threshold $\alpha$ and sampled $\min\{\alpha,|L_{i}|\}$ tuples from each $L_{i}$.

Lemma 3.2**.**

$\textnormal{{Reduce}}(G,b,y,L,\xi,\delta)$* behaves as claimed above, has running time $\mathcal{O}(|L|k^{3}\log(nb/\delta))$, and does not invoke cINDG**. *

Proof 3.3**.**

*Running time. It is clear that $\textnormal{{Reduce}}(G,b,y,L,\xi,\delta)$ does not invoke cIND*G. Recall that we work with the word-RAM model, so we can carry out elementary arithmetic operations on $\mathcal{O}(k\log n)$-bit numbers in $\mathcal{O}(k^{2})$ time. Thus step (T1) takes time $\mathcal{O}(k^{2}a|L|)$, and step (T2) takes time $\mathcal{O}(k^{2}a(\log(1/\delta)+|L|))$. Since $|L_{i}^{\prime}|=\min\{|L_{i}|,t_{i}\}$, steps (T3) and (T4) take time $\mathcal{O}(k^{2}a|L|)$. The required bounds follow.

Correctness.* In forming $L^{\prime}$ from $L$, Reduce only updates the first elements (i.e. the weights) of entries of $L$; since $L$ is a $(G,b,y)$-list, and the definition of a $(G,b,y)$-list does not depend on these weights, $L^{\prime}$ is also a $(G,b,y)$-list. We next prove (a). We have*

[TABLE]

Recall from the definition of $L_{i}$ that, for all $(w,S,\hat{e})\in L_{i}$, we have $w\hat{e}\geq 2^{i-1}$, so

[TABLE]

It therefore follows from (5) that $|L^{\prime}|\leq 2a+1+32b^{2}\log(2/\delta)/\xi^{2}$, so property (a) holds.

It remains to prove property (b). This will follow easily from Lemma 2.7. Before we can apply it, however, we must set our notation and prove the conditions of the lemma hold. Let

[TABLE]

thus in step (T3) of Reduce, for each $i\notin\mathcal{I}$ we choose $L_{i}^{\prime}=L_{i}$, and for each $i\in\mathcal{I}$ we choose $L_{i}^{\prime}$ by sampling $t_{i}$ elements $(w_{i,j},S_{i,j},\hat{e}_{i,j})$ from $L_{i}$. For each $i\in\mathcal{I}$ and $j\in[t_{i}]$, let

[TABLE]

For all $i$ and $j$, it is clear that $X_{i,j}\geq 0$. Moreover, since $L$ is a $(G,b,y)$-list and $(w_{i,j},S_{i,j},\hat{e}_{i,j})\in L$, we have $e(G[S_{i,j}])\leq b\hat{e}_{i,j}$; thus by the definitions of $L_{i}$ and $X_{i,j}$ we have

[TABLE]

It is also true that $\mathbb{E}(X_{i,j})=\mu_{i}$, that $0\leq\hat{\mu}_{i}\leq\mu_{i}b$, that the $X_{i,j}$’s are independent, and that

[TABLE]

It therefore follows from Lemma 2.7 that with probability at least $1-\delta$,

[TABLE]

Suppose this event occurs; then we will show that $Z(L^{\prime})\in(1\pm\xi)Z(L)$, as in (b).

Plugging our definitions into (6), we see that

[TABLE]

and

[TABLE]

so

[TABLE]

We have $L_{i}^{\prime}=L_{i}$ for all $i\in\{-a,\dots,a\}\setminus\mathcal{I}$, so it follows that

[TABLE]

For all $(w,S,\hat{e})\in L$, since $L$ is a $(G,b,y)$-list with $Z(L)\leq 2n^{k}$, we have

[TABLE]

Thus, for all $(w,S,\hat{e})\in L\setminus\bigcup_{|i|\leq a}L_{i}$, we have $w\hat{e}\leq 2^{-a}$. It follows from (7) that

[TABLE]

*Observe that by hypothesis, $\xi Z(L)/2\geq n^{-2k}/4$ and $2^{-a}|L|\leq n^{-2k}/4$. Hence, $Z(L^{\prime})\in(1\pm\xi)Z(L)$, as required. *

We next state the behaviour of our coarse approximate counting algorithm; we will prove the following lemma in Section 4.

Lemma 3.4**.**

There is a randomised algorithm $\textnormal{{Coarse}}(G,\delta)$ with the following behaviour. Suppose $G$ is an $n$-vertex $k$-hypergraph to which Coarse has (only) colourful oracle access, where $n$ is a power of two, and suppose $0<\delta<1$. Then in time $\mathcal{O}(\log(1/\delta)k^{3k}n\log^{2k+2}n)$, and using at most $\mathcal{O}(\log(1/\delta)k^{3k}\log^{2k+2}n)$ queries to cINDG*, $\textnormal{{Coarse}}(G,\delta)$ outputs a rational number $\hat{e}$. Moreover, with probability at least $1-\delta$,*

[TABLE]

Using Coarse, we now describe our algorithm for turning our $(G,b,y)$-list $L$ into a $(G,b,y-1)$-list $L^{\prime}$ with $Z(L^{\prime})\approx Z(L)$.

Algorithm $\textnormal{{Refine}}(G,b,y,L,\xi,\delta)$.

Input: $G$ is an $n$-vertex $k$-hypergraph, where $n$ is a power of 2, to which Refine has (only) colourful oracle access. $b$ is a rational number with $b\geq 2(4k\log n)^{k}$, and $y$ is a positive integer with $2^{y-1}\geq 2k^{2}$. $L$ is a $(G,b,y)$-list. $\xi$ and $\delta$ are rational numbers with $0<\xi,\,\delta<1$.

Behaviour: $\textnormal{{Refine}}(G,b,y,L,\xi,\delta)$ outputs a list $L^{\prime}$, which satisfies the following properties with probability at least $1-\delta$.

1. (a)

$L^{\prime}$ is a $(G,b,y-1)$-list. 2. (b)

$|L^{\prime}|\leq|L|+2^{k+3}b^{2}\log(4/\delta)/\xi^{2}$. 3. (c)

$Z(L^{\prime})\in(1\pm\xi)Z(L)$.

1. (H1)

Write $L=:\{(w_{i},S_{i},\hat{e}_{i})\colon 1\leq i\leq|L|\}$. Calculate

[TABLE]

[TABLE] 2. (H2)

For all $1\leq i\leq|L|$, sample subsets $S_{i,1},\dots,S_{i,t_{i}}\subseteq S_{i}$ independently and uniformly at random subject to $|S_{i,j}|=2^{y-1}$. Then calculate $w_{i}^{\prime}\leftarrow w_{i}/pt_{i}$ and

[TABLE] 3. (H3)

Form $L^{\prime}$ by concatenating the multisets $\{L_{i}^{\prime}\colon 1\leq i\leq|L|\}$ in an arbitrary order and removing any entries $(w,S,\hat{e})$ with $\hat{e}=0$, and return $L^{\prime}$.

Lemma 3.5**.**

$\textnormal{{Refine}}(G,b,y,L,\xi,\delta)$* behaves as claimed above. Moreover, writing*

[TABLE]

$\textnormal{{Refine}}(G,b,y,L,\xi,\delta)$* has running time $\mathcal{O}(nT)$ and invokes cINDG** at most $\mathcal{O}(T)$ times. *

Proof 3.6**.**

**Running time. The running time and oracle usage are both dominated by the invocations of Coarse in step (H2). We first bound the number $\sum_{i}t_{i}$ of such invocations. We have

[TABLE]

Since $2^{y-1}\geq 2k^{2}$, by a standard binomial coefficient bound (Lemma 2.5), we have $p\geq 2^{-k-1}$. Thus, (8) implies

[TABLE]

By Lemma 3.4, writing $T^{\prime}=\log(\lambda/\delta)k^{3k}\log^{2k+2}2^{y-1}$, Coarse has running time $\mathcal{O}(2^{y-1}T^{\prime})$ and invokes cINDG* $\mathcal{O}(T^{\prime})$ times. Since $L$ is a $(G,b,y)$-list, we have $2^{y-1}\leq n$ and so the claimed bounds follow from (9).*

Correctness.* Let $\mathcal{E}_{1}$ be the event that $Z(L^{\prime})\in(1\pm\xi)Z(L)$, and let $\mathcal{E}_{2}$ be the event that every invocation of Coarse in step (H2) succeeds. We will show that $\mathbb{P}(\mathcal{E}_{1}\cap\mathcal{E}_{2})\geq 1-\delta$, and that properties (a)–(c) hold whenever $\mathcal{E}_{1}\cap\mathcal{E}_{2}$ occurs.*

**Bounding $\boldsymbol{\mathbb{P}(\mathcal{E}_{1}\cap\mathcal{E}_{2})}$: To bound $\mathbb{P}(\mathcal{E}_{1})$ below, we will apply Lemma 2.7. We first explain the purpose of $p$, as defined in Refine. Since $L$ is a $(G,b,y)$-list, we have $|S_{i}|=2^{y}$ and $|S_{i-1}|=2^{y-1}$, so there are $\binom{2^{y}}{2^{y-1}}$ possible choices of each set $S_{i,j}$. Moreover, for any given edge $e\in E(G[S_{i}])$, there are $\binom{2^{y}-k}{2^{y-1}-k}$ possible choices of $S_{i,j}$ containing $e$. It follows that any given edge of $G[S_{i}]$ is present in $S_{i-1}$ with probability precisely $p$.

We now set up our notation and show that the relevant assumptions hold in order to apply Lemma 2.7. For all $1\leq i\leq|L|$ and all $j\in[t_{i}]$, let

[TABLE]

For all $i$ and $j$, it is clear that $X_{i,j}\geq 0$. Moreover, since $(w_{i},S_{i},\hat{e}_{i})\in L$, we have $e(G[S_{i,j}])\leq e(G[S_{i}])\leq\hat{e}_{i}b$, so $X_{i,j}\leq M_{i}$. Since $p$ is the probability that any given edge in $G[S_{i}]$ survives in $G[S_{i,j}]$, we have $\mu_{i}=\mathbb{E}(X_{i,j})$. The $X_{i,j}$’s are independent, we have $0\leq\hat{\mu}_{i}\leq\mu_{i}b$, and we have

[TABLE]

It therefore follows from Lemma 2.7 that with probability at least $1-\delta/2$,

[TABLE]

Plugging our definitions in, we see (10) implies that $Z(L^{\prime})\in(1\pm\xi)Z(L)$. Thus,

[TABLE]

By the correctness of Coarse (Lemma 3.4) and a union bound over all $1\leq i\leq|L|$ and all $j\in[t_{i}]$, we have $\mathbb{P}(\mathcal{E}_{2})\geq 1-\delta/2$. By a union bound with (11), we therefore have $\mathbb{P}(\mathcal{E}_{1}\cap\mathcal{E}_{2})\geq 1-\delta$ as claimed.

**Properties (a)–(c) hold: Suppose $\mathcal{E}_{1}\cap\mathcal{E}_{2}$ occurs. For every entry $(w,S,\hat{e})$ of $L^{\prime}$, $w$ and $\hat{e}$ are positive rational numbers and $S\subseteq V(G)$ with $|S|=2^{y-1}$. Since $\mathcal{E}_{2}$ occurs and $b\geq 2(4k\log n)^{k}$, by the correctness of *Coarse (Lemma 3.4) we have $\hat{e}/b\leq e(G[S])\leq\hat{e}b$. Thus, $L$ is a $(G,b,y-1)$-list as required by property (a). We have $|L^{\prime}|=\sum_{i}t_{i}$, so (9) implies that property (b) holds. Finally, since $\mathcal{E}_{1}$ occurs, property (c) holds. Thus, properties (a)–(c) all hold whenever $\mathcal{E}_{1}\cap\mathcal{E}_{2}$ occurs, which we have already shown happens with probability at least $1-\delta$. *

We now state our main algorithm.

Algorithm $\textnormal{{HelperCount}}(G,\varepsilon)$.

Input: $G$ is an $n$-vertex $k$-hypergraph, where $n$ is a power of 2. HelperCount only has colourful oracle access to $G$, and $\varepsilon$ is a rational number with $0<\varepsilon<1/2$.

Behaviour: $\textnormal{{HelperCount}}(G,\varepsilon)$ outputs a rational number $\hat{e}$ such that with probability at least 2/3, $\hat{e}\in(1\pm\varepsilon)e(G)$.

1. (A1)

If $\varepsilon<n^{-k}$, or if $n\leq 500$, then return $\sum_{Y\subseteq V(G),\ |Y|=k}(1-\textup{cIND}_{G}(Y))$. 2. (A2)

If $\textnormal{{Coarse}}(G,\delta)=0$, return [math]. Otherwise, let

[TABLE]

[TABLE] 3. (A3)

For $i=1$ to $I$:

(We will maintain the invariant that $L$ is a $(G,b,\log n-(i-1))$-list with $Z(L)\in(1\pm\xi)^{2i}e(G)$, and that $|L|$ is suitably small (see proof of Lemma 3.7). Note that this is trivially satisfied at the start of the loop.)

1. (A4)

Update $L\leftarrow\textnormal{{Refine}}(G,b,\log n-(i-1),L,\xi,\delta)$.

(This step turns $L$ into a $(G,b,\log n-i)$-list.) 2. (A5)

Update $L\leftarrow\textnormal{{Reduce}}(G,b,\log n-i,L,\xi,\delta)$.

(This step reduces the length of $L$.) 4. (A6)

For each entry $(w,S,\hat{e})\in L$, calculate

[TABLE] 5. (A7)

Output $\sum_{(w,S,\hat{e})\in L}we_{S}$.

Lemma 3.7**.**

With probability at least $2/3$, $\textnormal{{HelperCount}}(G,\varepsilon)$ outputs a rational number $\hat{e}\in(1\pm\varepsilon)e(G)$ as claimed above, has running time $\mathcal{O}(\varepsilon^{-2}k^{6k}n\log^{4k+7}n)$, and invokes cINDG* at most $\mathcal{O}(\varepsilon^{-2}k^{6k}\log^{4k+7}n)$ times. *

Proof 3.8**.**

Correctness. Lemma 3.4 implies that whenever $\textnormal{{HelperCount}}(G,\varepsilon)$ outputs on step (A1) or (A2), correctness holds, so suppose that this does not occur. For all integers $i\geq 0$, let $\pi(i)$ be the statement that $L$ satisfies the following properties.

1. (i)

$L$* is a $(G,b,\log n-i)$-list.* 2. (ii)

$Z(L)\in(1\pm\xi)^{2i}e(G)$. 3. (iii)

$|L|\leq 33k\log(4nb)+32b^{2}\log(2/\delta)/\xi^{2}$.

We will prove that with probability at least $2/3$, $\pi(i)$ holds at the end of the $i$th iteration of loop (A3) for all $i\in[I]$. Suppose this is true: we will show that correctness follows. With probability at least $2/3$, $\pi(I)$ holds when we exit the loop. In this case, the final value of $L$ satisfies $Z(L)\in(1\pm\xi)^{2I}e(G)$ by (ii). We have $(1-\xi)^{2I}\geq 1-2I\xi$, and $(1+\xi)^{2I}\leq e^{2I\xi}\leq 1+4I\xi$ (since $4I\xi=\varepsilon<1$), so

[TABLE]

Moreover, in step (A6) we have $e_{S}=e(G[S])$ for all $(w,S,\hat{e})\in L$, so $Z(L)$ is the output.

It remains to prove that with probability at least $2/3$, $\pi(i)$ holds at the end of the $i$th iteration of loop (A3) for all $i\in[I]$. Let $\mathcal{E}_{0}$ be the event that Coarse behaves correctly in step (A2); note that $\mathbb{P}(\mathcal{E}_{0})\geq 1-\delta$ by the correctness of Coarse (Lemma 3.4). For all $i\in[I]$, let $\mathcal{E}_{i}$ be the event that Refine behaves correctly in the $i$th iteration of step (A4) and Reduce behaves correctly in the $i$th iteration of step (A5). (If the input restrictions of Refine or Reduce are violated on the $i$th iteration, then $\mathcal{E}_{i}$ occurs automatically.) By correctness of Refine and Reduce (Lemmas 3.5 and 3.2), we have $\mathbb{P}(\mathcal{E}_{i}\mid\mathcal{E}_{0},\dots,\mathcal{E}_{i-1})\geq 1-2\delta$. Thus, by a union bound over all $0\leq i\leq I$, we have

[TABLE]

It therefore suffices to show that when $\bigcap_{j}\mathcal{E}_{j}$ occurs, $\pi(i)$ holds at the end of the $i$th iteration of loop (A3) for all $i\in[I]$.

At the start of the first iteration of loop (A3), when $i=1$, $L$ is a $(G,b,\log n)$-list since $\mathcal{E}_{0}$ occurs, $Z(L)=e(G)$, and $|L|=1$. Thus, $\pi(0)$ holds. Let $i\in[I]$, and suppose that $\pi(i-1)$ holds at the start of the $i$th iteration of loop (A3). Let $L_{i}$ be the value of $L$ at the start of the $i$th iteration, let $L_{i}^{\prime}$ be the value of $L$ after executing step (A4), and let $L_{i+1}$ be the value of $L$ after executing step (A5).

By property (i) of $\pi(i)$, $L_{i}$ is a $(G,b,\log n-(i-1))$-list, where by our choice of $I$ we have $2^{\log n-i}\geq 2k^{2}$. Since $\mathcal{E}_{i}$ occurs, it follows by the correctness of Refine (Lemma 3.5) that $L_{i}^{\prime}$ is a $(G,b,\log n-i)$-list with

[TABLE]

We next show that $1/2\leq Z(L_{i}^{\prime})\leq 2n^{k}$, that $|L_{i}^{\prime}|\leq n^{11k}$, and that $\xi\geq n^{-2k}$, as required by Reduce. Since property (ii) of $\pi(i)$ holds for $Z(L_{i})$, we have $Z(L_{i}^{\prime})\in(1\pm\xi)^{2i+1}e(G)\subseteq(1\pm\varepsilon)e(G)$. Since $\textnormal{{HelperCount}}(G,\varepsilon)$ did not halt at (A2), we have $1\leq e(G)\leq n^{k}$; since $\varepsilon<1/2$, it follows that $1/2\leq Z(L_{i}^{\prime})\leq 2n^{k}$. Since $\textnormal{{HelperCount}}(G,\varepsilon)$ did not halt at (A1), we have $n\geq 500$ and hence $n\geq 50\log n$. We also have $\varepsilon\geq n^{-k}$ and $k\leq n$. Hence:

[TABLE]

Since property (iii) of $\pi(i)$ holds for $L_{i}$, it follows that

[TABLE]

We have therefore shown that $L_{i}^{\prime}$ and $\xi$ satisfy the input restrictions of Reduce. Since $\mathcal{E}_{i}$ occurs, by the correctness of Reduce (Lemma 3.2) and by (12) it follows that $L_{i+1}$ is a $(G,b,\log n-i)$-list with

[TABLE]

Thus, properties (i)–(iii) hold for $L_{i+1}$, as required.

Running time and oracle queries.* If step (A1) is executed, so that $\varepsilon<n^{-k}$ or $n\leq 500$, then the algorithm runs in time $\mathcal{O}(n^{k})=\mathcal{O}(\varepsilon^{-1})$ and uses $\mathcal{O}(n^{k})=\mathcal{O}(\varepsilon^{-1})$ oracle queries, so our claimed bounds hold. Suppose instead step (A1) is not executed, so that $\varepsilon\geq n^{-k}$. Recall that $\bigcap_{i}\mathcal{E}_{i}$ holds with probability at least $2/3$. Suppose this occurs. The bottleneck in both running time and oracle invocations is then step (A4). For legibility, we give the time and oracle requirements of the other steps in the following table, giving justifications in the paragraph below. We write $\Lambda=33k\log(4nb)+32b^{2}\log(2/\delta)/\xi^{2}$ for the upper bound on $|L|$ in property (iii) of our invariant $\pi$.*

[TABLE]

For step (A1), we use the fact that $\varepsilon\geq n^{-k}$ and so the conditional does not trigger; we verify this fact in time $\mathcal{O}(k^{2})$. For step (A2), we use the fact that $n$ is a power of 2 (so computing $\log n$ is easy) and the time bounds on Coarse (Lemma 3.4). For step (A5), we first observe that the step is executed $I$ times. We then apply the time bounds on Reduce (Lemma 3.2), together with property (iii) of $\pi(i)$ and the fact that Refine adds at most $2^{k+3}b^{2}\xi^{-2}\log(4/\delta)$ to the length of $L$ (see Lemma 3.5). (Note that $k^{3}\log(nb/\delta)=\mathcal{O}(k^{4}\log n)$.) For step (A6), we use the fact that after the loop of (A3), $L$ is a $(G,b,\log n-I)$-list, so each entry $(w,S,\hat{e})$ of $L$ has $|S|=2^{\log n-I}\leq 4k^{2}$.

We now consider step (A4), which is executed $I$ times. From the time bounds of Refine (Lemma 3.5), it follows that the total running time of step (A4) is $\mathcal{O}(nT)$ and the total number of oracle accesses is $\mathcal{O}(T)$ times, where

[TABLE]

This clearly dominates everything in the table. Observe that $\Lambda=\mathcal{O}(2^{k}b^{2}\xi^{-2}\log(1/\delta))$, so $\lambda=\mathcal{O}(2^{k}b^{2}\xi^{-2}\log(1/\delta))$ also. Since $\varepsilon\geq n^{-k}$,

[TABLE]

Thus

[TABLE]

*and the claimed bounds follow. *

We now recall Section 1.1 and then prove it. See 1.1

Proof 3.9**.**

To evaluate $\textnormal{{Count}}(G,\varepsilon,\delta)$, we first make $n$ into a power of two by adding at most $n$ isolated vertices to $G$; note that this does not impede the evaluation of $\textup{cIND}_{G}$. We then run $\textnormal{{HelperCount}}(G,\min\{\varepsilon,1/3\})$ a total of $36\lceil\ln(2/\delta)\rceil$ times and return the median result $\hat{e}$. If some invocation of $\textnormal{{HelperCount}}(G,\min\{\varepsilon,1/3\})$ takes more than $\Theta(\varepsilon^{-2}k^{6k}n\log^{4k+7}n)$ time, or invokes $\textup{cIND}_{G}$ more than $\Theta(\varepsilon^{-2}k^{6k}\log^{4k+7}n)$ times, we halt execution and consider the output to be $-1$.

It is immediate that this algorithm satisfies our stated time bounds. Moreover, $\hat{e}\in(1\pm\varepsilon)e(G)$ unless at least half our invocations of HelperCount fail. The number of such failures is dominated above by a binomial variable $N$ with mean $12\lceil\ln(2/\delta)\rceil$, so by a standard Chernoff bound (namely Lemma 2.4(i)) we have

[TABLE]

*as required. *

4 Coarse approximate counting

In this section, we prove Lemma 3.4. We fix the input graph $G$ to be an $n$-vertex $k$-hypergraph to which we have (only) colourful oracle access, where $n$ is a power of two.

4.1 Sketch proof

The heart of our algorithm will be a subroutine to solve the following simpler “gap-version” of the problem. Given a $k$-partite $k$-hypergraph $G$ and a guess $M\geq 0$, we ask: Does $G$ have more than $M$ edges? We wish to answer correctly with high probability provided that either $G$ has at least $M$ edges, or $G$ has significantly fewer than $M$ edges, namely at most $\gamma M$ edges with $\gamma=1/(2^{3k+1}k^{2k}\log^{k}n)$. Suppose we can solve this problem probabilistically, perhaps outputting Yes with probability at least $1/50$ if $e(G)\geq M$ (which we call completeness) and outputting Yes with probability at most $1/100$ if $e(G)\leq\gamma M$ (which we call soundness). We then apply probability amplification to substantially reduce the failure probability, and use binary search to find the least $M$ such that our output is Yes— with high probability, this will approximate $e(G)$ when our input $k$-hypergraph is $k$-partite. We then generalise our algorithm to arbitrary inputs using random colour-coding. These parts of the algorithm are fairly standard, so in this sketch proof we will only solve the gap-problem. (We implement this sketch below as the VerifyGuess algorithm.)

Let $G$ be a $k$-partite $k$-hypergraph with vertex classes $X_{1},\dots,X_{k}$. The basic idea of the algorithm is to randomly remove vertices from $G$ to form a new graph $H$ in such a way that each edge survives with probability roughly $1/M$, and then query the colourful independence oracle and output Yes if and only if at least one edge remains. If $G$ has at most $\gamma M$ edges, then a union bound implies we are likely to output No (soundness); if $G$ has at least $M$ edges, then in expectation at least one edge survives the removal, so we hope to output Yes (completeness). Unfortunately, the number of edges remaining in $H$ need not be concentrated around its expectation — for example, if every edge of $G$ is incident to a single vertex $v$ — so we must be very careful if this hope is to be realised.

Suppose for the moment that $k=2$, so that $G$ is a bipartite graph with vertex classes $X_{1}$ and $X_{2}$. Then we will form $X_{1}^{\prime}\subseteq X_{1}$ by including each vertex independently with probability $p_{1}$, and $X_{2}^{\prime}\subseteq X_{2}$ by including each vertex independently with probability $p_{2}$. Each edge survives with probability $p_{1}p_{2}$, so we require $p_{1}p_{2}\leq 1/M$ to ensure soundness. To ensure completeness, we would then like to choose $p_{1}$ and $p_{2}$ such that $G[X_{1}^{\prime},X_{2}^{\prime}]$ is likely to contain an edge whenever $e(G)\geq M$.

To see that such a pair $(p_{1},p_{2})$ exists, we first partition the vertices in $X_{1}$ according to their degree: For $1\leq d\leq\log n$, let $X_{1}^{d}$ be the set of vertices $v$ with $2^{d-1}\leq d(v)<2^{d}$. By the pigeonhole principle, there exists some $D$ such that $X_{1}^{D}$ is incident to at least $e(G)/\log n$ edges. Then we take $p_{1}=2^{D}/M$ and $p_{2}=1/2^{D}$. We certainly have $p_{1}p_{2}\leq 1/M$. Suppose $e(G)\geq M$. Since $X_{1}^{D}$ is incident to at least $e(G)/\log n$ edges, we have $|X_{1}^{D}|\geq M/2^{D}\log n$, so with reasonable probability $X_{1}^{\prime}$ contains a vertex $v_{1}\in X_{1}^{D}$. Then $v_{1}$ has degree roughly $2^{D}$ in $X_{2}$, so again with reasonable probability $X_{2}^{\prime}$ contains a vertex adjacent to it.

There is one remaining obstacle: Since we only have colourful oracle access to $G$, we do not know what $D$ is! Fortunately, since there are only $\mathcal{O}(\log n)$ possibilities, we can simply try them all in turn, and output Yes if any one of them yields a pair $X_{1}^{\prime},\,X_{2}^{\prime}$ such that $G[X_{1}^{\prime},X_{2}^{\prime}]$ contains an edge. (It is not hard to tune the parameters so that this doesn’t affect soundness.) This is essentially the argument used by Beame et al. [7].

When we try to generalise this approach to $k$-hypergraphs, we hit a problem. For illustration, take $k=3$ and suppose $e(G)\geq M$. Then we wish to guess a vector $(p_{1},p_{2},p_{3})$ such that $p_{1}p_{2}p_{3}\leq 1/M$ and, with reasonable probability, $G[X_{1}^{\prime},X_{2}^{\prime},X_{3}^{\prime}]$ contains an edge. As in the $k=2$ case, we can guess an integer $0\leq D\leq 2\log n$ such that a large proportion of $G$’s edges are incident to a vertex in $X_{1}$ of degree roughly $2^{D}$. Also, as in the $k=2$ case, if we take $p_{1}=2^{D}/M$ then it is reasonably likely that $X_{1}^{\prime}$ will contain a vertex of degree roughly $2^{D}$, say $v_{1}$. But we cannot iterate this process — the structure of $G[v_{1},X_{2},X_{3}]$, and hence the “correct” value of $p_{2}$, depends very heavily on $v_{1}$. So for example, when we test the two guesses $(2^{D}/M,1/2^{D},1)$ and $(2^{D}/M,1,1/2^{D})$, we wish to ensure that the value of $v_{1}$ is the same in each test. This is the reason for step (C1) in the following algorithm; it is important that we do not choose new random subsets of $X_{1},\dots,X_{k}$ independently with each iteration of step (C2).

4.2 Solving the gap problem

Algorithm $\textnormal{{VerifyGuess}}(G,M,X_{1},\dots,X_{k})$.

Input: $G$ is an $n$-vertex $k$-hypergraph to which VerifyGuess has (only) colourful oracle access. $n$ and $M$ are positive powers of two, and $X_{1},\dots,X_{k}\subseteq V(G)$ are disjoint.

Behaviour: Let $p_{\mathsf{out}}=(8k\log n)^{-k}$.

Completeness: If $e(G[X_{1},\dots,X_{k}])\geq M$, then VerifyGuess outputs Yes with probability at least $p_{\mathsf{out}}$.

Soundness: If $e(G[X_{1},\dots,X_{k}])<M\cdot p_{\mathsf{out}}/2(k\log n)^{k}$, then VerifyGuess outputs Yes with probability at most $p_{\mathsf{out}}/2$.

1. (C1)

For each $i\in[k]$ and each $0\leq j\leq k\log n$, construct a subset $Y_{i,j}$ of $X_{i}$ by including each vertex independently with probability $1/2^{j}$. Construct the finite set $A$ of all tuples $(a_{1},\dots,a_{k})$ with $0\leq a_{1},\dots,a_{k}\leq k\log n$ and $a_{1}+\dots+a_{k}\geq\log M$. 2. (C2)

For each tuple $(a_{1},\dots,a_{k})\in A$: If $\textup{cIND}_{G}(Y_{1,a_{1}},\dots,\allowbreak Y_{k,a_{k}})=0$, then halt and output Yes. 3. (C3)

We have not halted yet, but do so now and output No.

Lemma 4.1**.**

VerifyGuess* behaves as stated, runs in time $\mathcal{O}(nk^{k}\log^{k}n)$, and makes at most $\mathcal{O}(k^{k}\log^{k}n)$ oracle queries. *

Proof 4.2**.**

Let $G,M,X_{1},\dots,X_{k}$ be the input for VerifyGuess, and write

[TABLE]

For notational convenience, we denote the gap in the soundness case by $\gamma$, that is, we set $\gamma:=p_{\mathsf{out}}/2(k\log n)^{k}=1/2^{3k+1}k^{2k}\log^{2k}n$.

Running time and oracle queries.* Step (C1) takes $\mathcal{O}(nk^{2}\log n+k^{k}\log^{k}n)$ time and no oracle queries; step (C2) takes $\mathcal{O}(k^{k}\log^{k}n)$ time and $\mathcal{O}(k^{k}\log^{k}n)$ oracle queries; and step (C3) takes $\mathcal{O}(1)$ time and no oracle queries. The claimed bounds follow, and it remains to prove that the soundness and completeness properties hold.*

Soundness.* We next prove soundness, as this is the easier part of proving correctness. So suppose $e(H)\leq\gamma M$. Let $(a_{1},\dots,a_{k})\in A$, and let $H^{\prime}\subseteq H$ denote the random induced subgraph $G[Y_{1,a_{1}},\dots,Y_{k,a_{k}}]$. Then for all $e\in E(H)$, we have*

[TABLE]

By a union bound over all $e\in E(H)$ and all $(a_{1},\dots,a_{k})\in A$, it follows that the probability that VerifyGuess outputs Yes is at most $p_{\mathsf{out}}/2$. This establishes the soundness of the algorithm, so it remains to prove completeness.

Completeness.* Suppose now that $e(H)\geq M$ holds. We show that VerifyGuess outputs Yes with probability at least $p_{\mathsf{out}}$. It suffices to show that with probability at least $p_{\mathsf{out}}$, there is at least one setting of the vector $(a_{1},\dots,a_{k})\in A$ such that $G[Y_{1,a_{1}},\dots,Y_{k,a_{k}}]$ contains at least one edge.*

We will define this setting iteratively. First, with reasonable probability, we will find an integer $a_{1}$ and a vertex $v_{1}\in Y_{1,a_{1}}$ such that $G[v_{1},X_{2},\dots,X_{k}]$ contains roughly $2^{-a_{1}}e(H)$ edges. In the process, we expose $Y_{1,a_{1}}$. We then, again with reasonable probability, find an integer $a_{2}$ and a vertex $v_{2}\in Y_{2,a_{2}}$ such that $G[v_{1},v_{2},X_{3},\dots,X_{k}]$ contains roughly $2^{-a_{1}-a_{2}}e(H)$ edges. Continuing in this vein, we eventually find $(a_{1},\dots,a_{k})\in A$ and vertices $v_{i}\in Y_{i,a_{i}}$ such that $\{v_{1},\dots,v_{k}\}$ is an edge in $G[Y_{1,a_{1}},\dots,Y_{k,a_{k}}]$, proving the result.

More formally, recall from Section 2.1 that for all $i\in[k]$ and $v_{1},\dots,v_{i}\in V(G)$, $d_{H}(v_{1},\dots,v_{i})$ is the number of edges in $H$ containing $\{v_{1},\dots,v_{i}\}$ as a subset. For all $i\in[k]$, let $\mathcal{E}_{i}$ be the event that there exist $0\leq a_{1},\dots,a_{i}\leq k\log n$ and $v_{1},\dots,v_{i}\in V(H)$ such that:

1. (a)

for all $j\in[i]$, $v_{j}\in Y_{j,a_{j}}$; 2. (b)

we have $d_{H}(v_{1},\dots,v_{i})\geq e(H)/\prod_{j=1}^{i}2^{a_{j}}$.

We make the following Claim: $\mathbb{P}(\mathcal{E}_{1})\geq 1/(8k\log n)$ and, for all $2\leq i\leq k$, $\mathbb{P}(\mathcal{E}_{i}\mid\mathcal{E}_{i-1})\geq 1/(8k\log n)$.

**Proof of Lemma 4.1 from Claim: Suppose $\mathcal{E}_{k}$ occurs, and let $a_{1},\dots,a_{k}$ and $v_{1},\dots,v_{k}$ be as in the definition of $\mathcal{E}_{k}$. By (b), $d_{H}(v_{1},\dots,v_{k})>0$, so $\{v_{1},\dots,v_{k}\}$ is an edge in $H$; it follows by (a) that it is also an edge in $G[Y_{1,a_{1}},\dots,Y_{k,a_{k}}]$. Also by (b), since $d_{H}(v_{1},\dots,v_{k})=1$, we have $\prod_{j=1}^{k}2^{a_{j}}\geq e(H)\geq M$, so $a_{1}+\dots+a_{k}\geq\log M$. Thus, $(a_{1},\dots,a_{k})\in A$, so whenever $\mathcal{E}_{k}$ occurs, VerifyGuess outputs Yes on reaching $(a_{1},\dots,a_{k})$ in step (C2). By the Claim, we have

[TABLE]

so completeness follows. The lemma statement therefore follows as well.

Proof of Claim: We first prove the claim for $\mathcal{E}_{1}$. We will choose $a_{1}$ depending on the degree distribution of vertices in $X_{1}$. For all integers $1\leq d\leq k\log n$, let

[TABLE]

be the set of vertices in $X_{1}$ with degree roughly $2^{d}$. Every edge in $H$ is incident to exactly one vertex in exactly one set $X_{1}^{d}$, so there exists $D$ such that $X_{1}^{D}$ is incident to at least $e(H)/k\log n$ edges of $H$. We take $a_{1}:=\lceil\log e(H)\rceil-D+1$. Note that $0\leq a_{1}\leq k\log n$, since $X_{1}^{D}\neq\emptyset$ and so $e(H)\geq 2^{D-1}$.

We would like to take $v_{1}\in Y_{1,a_{1}}\cap X_{1}^{D}$, so we next bound the probability that this set is non-empty. We have

[TABLE]

Since every vertex in $X_{1}^{D}$ has degree at most $2^{D}$, by the definition of $D$ we have $2^{D}|X_{1}^{D}|\geq e(H)/(k\log n)$. Moreover, we have $a_{1}\leq\log e(H)-D+2$. It follows that

[TABLE]

Suppose $X_{1}^{D}\cap Y_{1,a_{1}}\neq\emptyset$, and take $v_{1}\in X_{1}^{D}\cap Y_{1,a_{1}}$. Then $v_{1}$ certainly satisfies (a), and by the definitions of $a_{1}$ and $X_{1}^{D}$ we have $e(H)/2^{a_{1}}\leq 2^{D-1}\leq d_{H}(v_{1})$, so $v_{1}$ also satisfies (b). We have therefore shown $\mathbb{P}(\mathcal{E}_{1})\geq 1/(8k\log n)$ as required.

Now let $2\leq i\leq k$. The argument is similar, but we include it explicitly for the benefit of the reader. We first expose $Y_{1,a_{1}},\dots,Y_{i-1,a_{i-1}}$: Let $\mathcal{F}$ be a possible filtration of these variables consistent with $\mathcal{E}_{i-1}$, and let $a_{1},\dots,a_{i-1}$ and $v_{1},\dots,v_{i-1}$ be as in the definition of $\mathcal{E}_{i-1}$. It then suffices to show that $\mathbb{P}(\mathcal{E}_{i}\mid\mathcal{F})\geq 1/(8k\log n)$.

Similarly to the $i=1$ case, for all integers $1\leq d\leq k\log n$, let

[TABLE]

Every edge in $H[v_{1},\dots,v_{i-1},X_{i},\dots,X_{k}]$ is incident to exactly one vertex in exactly one set $X_{i}^{d}$, so there exists $D_{i}$ such that $X_{i}^{D_{i}}$ is incident to at least

[TABLE]

edges of $H[v_{1},\dots,v_{i-1},X_{i},\dots,X_{k}]$. We take $a_{i}:=\lceil\log d_{H}(v_{1},\dots,v_{i-1})\rceil-D_{i}+1$; note that $0\leq a_{i}\leq k\log n$.

As in the $i=1$ case, we would like to take $v_{i}\in Y_{i,a_{i}}\cap X_{i}^{D_{i}}$, so we next bound the probability that this set is non-empty. Since every vertex $v\in X_{i}^{D_{i}}$ satisfies $d_{H}(v_{1},\dots,v_{i-1},v)\leq 2^{D_{i}}$, we have $2^{D_{i}}|X_{i}^{D_{i}}|\geq d_{H}(v_{1},\dots,v_{i-1})/k\log n$. It follows that

[TABLE]

Suppose $X_{i}^{D_{i}}\cap Y_{i,a_{i}}\neq\emptyset$, and take $v_{i}\in X_{i}^{D_{i}}\cap Y_{i,a_{i}}$. Then $v_{i}$ certainly satisfies (a). By the definitions of $a_{i}$ and $X_{i}^{D_{i}}$, and the fact that $v_{1},\dots,v_{i-1}$ satisfy (b), we have

[TABLE]

*Thus, (b) is satisfied, and we have shown $\mathbb{P}(\mathcal{E}_{i}\mid\mathcal{F})\geq 1/(8k\log n)$ as required. *

4.3 Proving Lemma 3.4

We next turn VerifyGuess into a crude approximation algorithm for $k$-partite $k$-hypergraphs in the natural way.

Algorithm $\textnormal{{ColourCoarse}}(G,X_{1},\dots,X_{k})$.

Input: $G$ is an $n$-vertex $k$-hypergraph, where $n$ is a power of two, to which ColourCoarse has colourful oracle access (only). $X_{1},\dots,X_{k}$ form a partition of $V(G)$.

Behaviour: Let $b:=(4k\log n)^{k}$. Then ColourCoarse ($G$) outputs a non-negative integer $m$ such that, with probability at least $2/3$, $m/b\leq e(G[X_{1},\dots,X_{k}])\leq mb$.

1. (D1)

Set $p_{\mathsf{out}}:=(8k\log n)^{-k}$ and $N:=\lceil 48\ln(6k\log n)/p_{\mathsf{out}}\rceil$. 2. (D2)

For each $M$ in $\{1,2,4,8,\dots,n^{k}\}$: Execute VerifyGuess $(G,M,X_{1},\dots,X_{k})$ a total of $N$ times, and let $S_{M}\in\{0,\dots,N\}$ be the number of executions that returned Yes. (Naturally we use independent randomness for each value of $M$.) 3. (D3)

If $\textup{cIND}_{G}(X_{1},\dots,X_{k})=1$, let $m=0$. Otherwise, if there exists $M$ such that $S_{M}\geq\frac{3}{4}p_{\mathsf{out}}N$, let $m$ be the least such $M$. Otherwise, let $m=n^{k}$. Output m\big{(}p_{\mathsf{out}}/2k^{k}\log^{k}n\big{)}^{1/2}.

Lemma 4.3**.**

ColourCoarse* behaves as stated, runs in time $\mathcal{O}((8k\log n)^{2k+2}n)$, and requires $\mathcal{O}((8k\log n)^{2k+2})$ oracle queries. *

Proof 4.4**.**

Let $G$ and $X_{1},\dots,X_{k}$ be the inputs, so that $G$ is an $n$-vertex $k$-hypergraph and $X_{1},\dots,X_{k}$ partition $V(G)$.

**Running time and oracle queries. Observe $N=\mathcal{O}((8k\log n)^{k+1})$. The algorithm ColourCoarse executes VerifyGuess at most $\mathcal{O}(\log(n^{k})N)$ times. By Lemma 4.1, each execution takes $\mathcal{O}(nk^{k}\log^{k}n)$ time and makes $\mathcal{O}(k^{k}\log^{k}n)$ oracle queries. Thus the claimed bounds on the running time and number of oracle queries of ColourCoarse follow.

**Correctness. Let $M\in\{1,2,4,8,\dots,n^{k}\}$, and let $H=G[X_{1},\dots,X_{k}]$. For this fixed $M$, the algorithm invokes VerifyGuess $N$ times, so the random variable $S_{M}$ is the sum of $N$ independent indicator variables. By a standard Chernoff bound (Lemma 2.4(i) taking $\varepsilon=1/4$),

[TABLE]

If $e(H)\geq M$, then the completeness of VerifyGuess implies $\mathbb{E}(S_{M})\geq Np_{\mathsf{out}}$. Thus, (13) and our choice of $N$ imply that

[TABLE]

Similarly, if $e(H)<Mp_{\mathsf{out}}/(2(k\log n)^{k})$, then the soundness of VerifyGuess implies $\mathbb{E}(S_{M})\leq Np_{\mathsf{out}}/2$. But then (13) implies that

[TABLE]

Finally, we perform a union bound over all $M\in\{1,2,4,8,\dots,n^{k}\}$ that satisfy either $e(H)\geq M$ or $e(H)\leq Mp_{\mathsf{out}}/(2k^{k}\log^{k}n)$. (Note that no value of $M$ satisfies both inequalities.) There are at most $k\log n$ such $M$’s, so with probability at least $2/3$, we see $S_{M}>3Np_{\mathsf{out}}/4$ whenever $e(H)\geq M$ and $S_{M}<3Np_{\mathsf{out}}/4$ whenever $e(H)\leq Mp_{\mathsf{out}}/(2k^{k}\log^{k}n)$. By the definition of $m$, it follows that in this case

[TABLE]

Hence, writing $x=m(p_{\mathsf{out}}/2k^{k}\log^{k}n)^{1/2}$ for the output of ColourCoarse,

[TABLE]

*Since $p_{\mathsf{out}}=1/(8k\log n)^{k}$, the output of ColourCoarse approximates $e(H)$ up to a factor of $(4k\log n)^{k}$ as required. *

We now combine our algorithm for coarsely approximately counting edges in $k$-partite $k$-hypergraphs with colour-coding to obtain an algorithm for general $k$-hypergraphs.

Algorithm $\textnormal{{HelperCoarse}}(G)$.

Input: $G$ is an $n$-vertex $k$-hypergraph, where $n$ is a power of two, to which HelperCoarse has colourful oracle access (only).

Behaviour: $\textnormal{{HelperCoarse}}(G)$ outputs a non-negative integer $\hat{e}$ which, with probability at least $2/3$, satisfies $\hat{e}/2(4k\log n)^{k}\leq e(G)\leq\hat{e}\cdot 2(4k\log n)^{k}$.

1. (E1)

Let $t=12e^{2k}$, and let $T=\lceil 72\ln t\rceil+3$. 2. (E2)

For each $i\in[t]$:

1. (E3)

Sample a uniformly random function $c_{i}:V(G)\to[k]$, which yields a random $k$-partition $X_{1},\dots,X_{k}$ of $V(G)$. 2. (E4)

Execute $\textnormal{{ColourCoarse}}(G,X_{1},\dots,X_{k})$ exactly $T$ times and let $M_{i}$ be the median output produced by these executions. 3. (E3)

Output $\frac{k^{k}}{tk!}\sum_{i=1}^{t}M_{i}$.

Lemma 4.5**.**

HelperCoarse* behaves as stated, runs in time $\mathcal{O}(k^{3k}n\log^{2k+2}n)$, and requires $\mathcal{O}(k^{3k}\log^{2k+2}n)$ oracle queries. *

Proof 4.6**.**

Let $G$ be an $n$-vertex $k$-hypergraph input for HelperCoarse.

**Running time and oracle queries. It is clear that the bottleneck in both the running time and the number of oracle queries is the $Tt$ total invocations of ColourCoarse. Recall from Lemma 4.3 that each such invocation runs in time $\mathcal{O}(n(8k\log n)^{2k+2})$ and requires $\mathcal{O}((8k\log n)^{2k+2})$ oracle queries. Since $t=\mathcal{O}(e^{2k})$ and $T=\mathcal{O}(k)$, the claimed bounds follow.

**Correctness. Let $b:=(4k\log n)^{k}$ be the approximation ratio of ColourCoarse. For all $i\in[t]$, let $G_{i}=G[c_{i}^{-1}(1),\dots,c_{i}^{-1}(k)]$ be the $i$th hypergraph we consider, and let $m_{i}=e(G_{i})$. Let $x_{i,j}$ be the output of the $j$th call to ColourCoarse in evaluating $M_{i}$, and let $\mathcal{E}_{i,j}$ be the event that $x_{i,j}/b\leq m_{i}\leq x_{i,j}b$.

Note that the $\mathcal{E}_{i,j}$’s are independent conditioned on $c_{i}$, and that the correctness of ColourCoarse (Lemma 4.3) implies that $\mathbb{P}(\mathcal{E}_{i,j})\geq 2/3$ for all $j\in[T]$. Moreover, for all $i\in[t]$, if at least half the $\mathcal{E}_{i,j}$’s occur, then $M_{i}/b\leq m_{i}\leq bM_{i}$. Thus, by a Chernoff bound (Lemma 2.4(i) applied with $\varepsilon=1/4$ and $\mu=2T/3$), we have

[TABLE]

It follows by a union bound that, with probability at least $5/6$, $M_{i}/b\leq m_{i}\leq bM_{i}$ for all $i\in[t]$.

Now observe that $\mathbb{E}(\sum_{i}m_{i})=t(k!/k^{k})e(G)$, and that each $m_{i}$ lies in $[0,e(G)]$. It follows by Hoeffding’s inequality (Lemma 2.1) that

[TABLE]

By Stirling’s formula and our definition of $t$, it follows that

[TABLE]

Thus, with probability at least $5/6$, we have $e(G)/2\leq\tfrac{k^{k}}{tk!}\sum_{i}m_{i}\leq 2e(G)$.

*It now follows by a union bound that with probability at least $2/3$, $\frac{1}{2b}\cdot e(G)\leq\tfrac{k^{k}}{tk!}\sum_{i}M_{i}\leq 2b\cdot e(G)$ as required. *

We now restate Lemma 3.4 and prove it via the usual probability amplification argument. See 3.4

Proof 4.7**.**

*Given $G$ and $\delta>0$, we simply invoke $\textnormal{{HelperCoarse}}(G)$ a total of $T:=\lceil 36\ln(2/\delta)\rceil$ times and return the median output. By the correctness of HelperCoarse (Lemma 4.5), each invocation returns a valid approximation of $e(G)$ with probability at least $2/3$, and if at least $T/2$ invocations return valid approximations then the median is also a valid approximation. It follows by Chernoff bounds (Lemma 2.4(i) with $\varepsilon=1/2$ and $\mu=T/3$) that we output a valid approximation with probability at least $1-2e^{-T/36}\geq 1-\delta$, as required, and our bounds on running time and oracle usage are immediate from Lemma 4.5. *

5 Approximately uniform sampling

In this section we demonstrate that we can use our approximate counting algorithm to sample an edge almost uniformly at random, proving Section 1.1. We begin by sketching our algorithm.

Suppose for the moment that we are given access to a deterministic algorithm $\texttt{ExactCount}(G)$ which, given colourful oracle access to a $k$-hypergraph $G$, returns the exact value of $|E(G)|$. Let $G$ be an $n$-vertex $k$-hypergraph for which we have access to a colourful independence oracle, and suppose further that $n$ is a power of two and that $G$ contains at least one edge. In this hypothetical scenario, we could proceed to sample an edge of $G$ from the exact uniform distribution using iterated rejection sampling as follows.

Let $X_{1}=V(G)$ and $M_{1}=\texttt{ExactCount}(G)$. Choose a uniformly random subset $X\subset X_{1}$ of size $n/2$, and let $M=\texttt{ExactCount}(G[X])$. With probability $M/M_{1}$, we “accept” $X$, setting $X_{2}=X$ and $M_{2}=M$. Otherwise, we “reject” $X$, reinitialising it to a new uniformly random size-$(n/2)$ subset, and repeat the process until we accept some set $X$. Likewise, we then choose a uniformly-random subset $X\subset X_{2}$ of size $n/4$ and let $M=\texttt{ExactCount}(G[X])$; with probability $M/M_{2}$, we “accept” $X$, setting $X_{3}=X$ and $M_{3}=M$, and otherwise we “reject” $X$ and resample. Continuing in this way, we generate two sequences $X_{1},\dots,X_{I}$ and $M_{1},\dots,M_{I}$ with $|X_{i}|=n/2^{i-1}$ for all $i\leq I$, where $I$ is chosen so that $k\leq|X_{I}|\leq 2k$. We then enumerate the edges of $G[X_{I}]$ directly using $O(2^{k})$ calls to the colourful independence oracle, and output a uniformly random such edge $F$.

Observe that by a standard rejection sampling argument (see e.g. Florescu [25, Proposition 3.3]), for any possible value $(Y_{1},\dots,Y_{I},e)$ of $(X_{1},\dots,X_{I},F)$, we have

[TABLE]

Since for each $i$, each edge of $G[Y_{i}]$ contributes 1 to exactly $\binom{|Y_{i}|-k}{|Y_{i}|/2-k}$ terms in the sum above and 0 to the rest, it follows that

[TABLE]

On summing over all possible sequences $Y_{1},\dots,Y_{I}$, we recover that $\mathbb{P}(F=e)=1/|E(G)|$ as required. Moreover, each edge of $G[X_{i}]$ appears in $G[X_{i+1}]$ with probability roughly $1/2^{k}$, so in expectation we will reject roughly $2^{k}$ samples before accepting each $X_{i}$, for a total of $\mathcal{O}(2^{k}\log n)$ calls to ExactCount.

Of course, Count is neither a deterministic nor an exact counting algorithm. However, with careful bookkeeping, essentially the same algorithm turns out to yield an approximate sample. We do the bulk of the work with the following ancillary algorithm $\textnormal{{HelperSample}}(G,\varepsilon)$, which assumes that $|V(G)|$ is a power of two and that $G$ contains at least one edge; we then address these assumptions (which will be easy) in the main proof of Section 1.1 later in the section.

Algorithm $\textnormal{{HelperSample}}(G,\varepsilon)$.

Input: $G$ is an $n$-vertex $k$-hypergraph containing at least one edge, where $n$ is a power of two, to which HelperCoarse has colourful oracle access (only). $0<\varepsilon<1/2$ is a rational number.

Behaviour: With probability at least $1-\varepsilon/n^{k}$, $\textnormal{{HelperSample}}(G,\varepsilon)$ outputs a sample from a distribution $\hat{U}$ on $E(G)$ such that, for all $e\in E(G)$, $\hat{U}(e)\in(1\pm\varepsilon)/e(G)$.

1. (S1)

If $\varepsilon\leq n^{-k}$, then enumerate the edges of $G$ using $\binom{n}{k}$ invocations of $\textup{cIND}_{G}$ and return a uniformly-sampled edge. 2. (S2)

Let $I=\log n-\lceil\log(8k^{2})\rceil$, $\xi=\varepsilon/(100\log n)$, and $\delta=\xi/2^{k+8}n^{2k}$. If $I\leq 1$, enumerate the edges of $e(G)$ using $\textup{cIND}_{G}$ and return a uniformly random sample. 3. (S3)

Let $X_{1}\leftarrow V(G)$, $M_{1}\leftarrow\textnormal{{Count}}(X_{1},\xi,\delta)$, and $i\leftarrow 2$. While $i\leq I$:

1. (a)

Choose a size-$(|X_{i-1}|/2)$ set $X\subseteq X_{i-1}$ uniformly at random, and let $M\leftarrow\textnormal{{Count}}(G[X],\xi,\delta)$. 2. (b)

If $M_{i-1}=0$, output Fail. Otherwise, with probability $\max\{0,1-M/M_{i-1}\}$, go to (a) (i.e. reject $X$ and resample). 3. (c)

Accept $X$ by setting $X_{i}\leftarrow X$, $M_{i}\leftarrow M$ and $i\leftarrow i+1$. 4. (S4)

Enumerate the edges of $G[X_{I}]$ using cINDG and return a uniformly random sample.

Lemma 5.1**.**

$\textnormal{{HelperSample}}(G,\varepsilon)$* behaves as claimed. With probability at least $1-\varepsilon/n^{k}$, writing $T=\varepsilon^{-2}k^{7k}\log^{4k+11}n$, its running time is $\mathcal{O}(nT)$, and it invokes $\textup{cIND}_{G}$ at most $\mathcal{O}(T)$ times. *

Proof 5.2**.**

If $\varepsilon\leq n^{-k}$ or $I\leq 1$, then both correctness and the stated time bounds are clear, so suppose $\varepsilon>n^{-k}$ and $I\geq 2$ (which implies $n\geq 32k^{2}$). We first carefully bound the probability that something goes wrong over the course of the algorithm’s execution.

We define events as follows for all $r\in[I]$:

• •

Let $\mathcal{E}_{r}$ be the event that in step (S3) Count is called at most $2^{k+3}\ln(\tfrac{8In^{k}}{\varepsilon})$ times in calculating $M_{r}$, that each time it is called it returns $M$ satisfying $M\in(1\pm\xi)e(G[X])$, and that $M_{r}>0$.

• •

Let $\mathcal{E}_{r,1}$ be the event that when $i=r$, we accept a set $X_{r}$ within $2^{k+3}\ln(\tfrac{8In^{k}}{\varepsilon})$ iterations of (S3a)–(S3c).

• •

Let $\mathcal{E}_{r,2}$ be the event that when $i=r$, we accept a set $X_{r}$ without Count ever returning an inaccurate estimate $M\notin(1\pm\xi)e(G[X])$.

Intuitively, $\mathcal{E}_{r}$ is the event that the algorithm behaves as we expect in determining $X_{r}$. We will use $\mathcal{E}_{r,1}$ and $\mathcal{E}_{r,2}$ to bound $\mathbb{P}(\mathcal{E}_{r}\mid\mathcal{E}_{1},\dots,\mathcal{E}_{r-1})$ below for all $r\in[I]$, and hence bound $\mathbb{P}(\mathcal{E}_{1},\dots,\mathcal{E}_{r})$ below. When $r=1$, it follows from Section 1.1 and the fact that $e(G)>0$ that $\mathbb{P}(\mathcal{E}_{1})\geq 1-\delta$.

Let $2\leq r\leq I$, let $\mathcal{F}$ be a possible filtration of $X_{1},\dots,X_{r-1}$ and $M_{1},\dots,M_{r-1}$ compatible with $\mathcal{E}_{1},\dots,\mathcal{E}_{r-1}$, and let $Y$ be the value of $X_{r-1}$ determined by $\mathcal{F}$. Note that if $\mathcal{E}_{r,2}\cap\mathcal{F}$ occurs, then $M_{r}\in(1\pm\xi)e(G[X_{r}])$; moreover, since we accepted $X_{r}$ with probability at most $M_{r}/M_{r-1}$, we must have $M_{r}>0$. Thus

[TABLE]

To bound $\mathbb{P}(\mathcal{E}_{r,1}\cap\mathcal{E}_{r,2}\mid\mathcal{F})$ below, consider the first iteration of (S3a)–(S3c) with $i=r$. In this iteration, let $\mathcal{A}_{1}$ be the event that Count returns an inaccurate estimate $M$, and let $\mathcal{A}_{2}$ be the event that Count returns an accurate estimate $M$ and we subsequently accept $X$; note that each of these events is independent of past samples, and that their probability does not depend on the value of $i$. By Section 1.1, we accept $X$ in any given round with probability at least $\mathbb{P}(\mathcal{A}_{2}\mid\mathcal{F})-\delta$; hence

[TABLE]

Let $T$ be the number of iterations of (S3a)–(S3c) before either Count returns an inaccurate estimate or we accept an accurate estimate. By Bayes’ theorem, for all $t\geq 0$, we have

[TABLE]

Summing over all values of $t$ yields

[TABLE]

We now bound $\mathbb{P}(\mathcal{A}_{1}\mid\mathcal{F})$ above and $\mathbb{P}(\mathcal{A}_{2}\mid\mathcal{F})$ below. Section 1.1 implies that

[TABLE]

Moreover, for all $S\subset Y$ with $|S|=|Y|/2$, Section 1.1 implies that

[TABLE]

By the definition of $\mathcal{F}$ we have $M_{r-1}\in(1\pm\xi)e(G[Y])$, so it follows that

[TABLE]

On summing both sides over $S$, since each edge of $G[Y]$ appears in exactly $\binom{|Y|-k}{|Y|/2-k}$ sets $S\subset Y$ with $|S|=|Y|/2$, we obtain

[TABLE]

Since $r\leq I$, we have $|Y|\geq n/2^{I-1}\geq 4k^{2}$, so by Lemma 2.5 it follows that $\mathbb{P}(\mathcal{A}_{2}\mid\mathcal{F})\geq 2^{-k-2}$. It therefore follows from (15), (16) and (17) that

[TABLE]

By (14), it follows that $\mathbb{P}(\mathcal{E}_{r}\mid\mathcal{F})\geq 1-\varepsilon/4In^{k}$ for all $r\in[I]$. Thus

[TABLE]

With these equations in hand, we are now ready to proceed with the main proof.

**Running time and oracle queries. Since $|X_{I}|=n/2^{I-1}\leq 32k^{2}$ by our choice of $I$, the bottleneck in the running time is the invocations of Count in (S3b). By Section 1.1, each invocation takes time

[TABLE]

and requires $\mathcal{O}(\log(1/\delta)\xi^{-2}k^{6k}\log^{4k+7}n)$ invocations of the oracle. Since $1/\xi=\mathcal{O}((\log n)/\varepsilon)$, $\log(1/\delta)=\mathcal{O}(k\log n+\log(1/\varepsilon))$ and $1/\varepsilon=\mathcal{O}(n^{k})$, each invocation takes time $\mathcal{O}(\varepsilon^{-2}k^{6k+1}n\log^{4k+10}n)$ and requires $\mathcal{O}(\varepsilon^{-2}k^{6k+1}\log^{4k+10}n)$ oracle invocations. As by (19), with probability at least $1-\varepsilon/n^{k}$ there are at most $2^{k+3}\ln(8In^{k}/\varepsilon)=\mathcal{O}(k2^{k}\log n)$ such invocations, the claimed bounds follow.

Correctness. Let $F$ be the output of $\textnormal{{HelperSample}}(G,\varepsilon)$, or Fail if it does not halt. Since $e(G)>0$, by (19), $\textnormal{{HelperSample}}(G,\varepsilon)$ outputs a sample from $E(G)$ with probability at least $1-\varepsilon/n^{k}$; thus to prove Lemma 5.1, it suffices to show that for all $f\in E(G)$ we have $\mathbb{P}(F=f)\in(1\pm\varepsilon)/e(G)$.

Let $S_{1}=V(G)$ and, for all $S_{1}\supset S_{2}\supset\dots\supset S_{I}\supset f$ with $|S_{r}|=n/2^{r-1}$ for all $r\in[I]$, let

[TABLE]

Thus for all $f\in E(G)$, we have

[TABLE]

By (19), it follows that

[TABLE]

To bound each term $p(S_{1},\dots,S_{I},f)$, we first derive estimates for the probability that $X_{r}=S_{r}$, conditioned on $X_{t}=S_{t}$ for all $t\in[r-1]$ and on $\mathcal{E}_{1},\dots,\mathcal{E}_{r-1}$. Let $\mathcal{F}_{r}$ be an arbitrary filtration of $X_{1},\dots,X_{r-1}$ and $M_{1},\dots,M_{r-1}$ compatible with these events. For all $S\subset S_{r-1}$ with $|S|=|S_{r-1}|/2$, let $q(S)$ be the probability that we accept $S$ on a given iteration of (S3a)–(S3c) conditioned on $X=S$ and $\mathcal{F}_{r}$. Then by Section 1.1 and the definition of $\mathcal{F}_{r}$,

[TABLE]

Moreover, by a standard rejection sampling argument (see e.g. Florescu [25, Proposition 3.3]), we have

[TABLE]

By (21) and (22), and using the fact that $e(G[S_{r}])\geq 1$, we have

[TABLE]

Since each edge of $G[S_{r-1}]$ appears exactly $\binom{|S_{r-1}|-k}{|S_{r-1}|/2-k}$ times in this sum, it follows that

[TABLE]

(Here the last inequality follows since $\xi<1/20$.)

Also by (21) and (22), we have

[TABLE]

Since there are $\binom{|S_{r-1}|}{|S_{r-1}|/2}$ terms in the sum, and since each edge of $G[S_{r-1}]$ contributes 1 to $\binom{|S_{r-1}|-k}{|S_{r-1}|/2-k}$ terms of the sum and zero to the rest, it follows that

[TABLE]

Since $|S_{r-1}|=n/2^{r-1}\geq 4k^{2}$, by Lemma 2.5 we have

[TABLE]

It follows that

[TABLE]

With upper and lower bounds on $\mathbb{P}(X_{r}=S_{r}\mid\mathcal{F}_{r})$ now in place, we return to the task of bounding $p(S_{1},\dots,S_{I},f)$. Observe that for all $f\in E(G)$,

[TABLE]

It therefore follows from (23) that

[TABLE]

(Recall that $e(G[S_{r}])\geq 1$ for all $r\in[I]$.) We have $(1+8\xi)^{I}\leq e^{8I\xi}\leq 1+16I\xi$, so on collapsing the telescoping product we obtain

[TABLE]

All terms of this sum are equal, and there are precisely $\prod_{r=0}^{I-2}\binom{n/2^{r}-k}{n/2^{r+1}-k}$ terms, so

[TABLE]

Hence by (20), we have $\mathbb{P}(F=f)\leq(1+\varepsilon)/e(G)$, as required.

Similarly, it follows from (24) that

[TABLE]

By (18), the last term is bounded above by $\varepsilon/4n^{k}$; it follows that

[TABLE]

*It therefore follows from (20) that $\mathbb{P}(F=f)\geq(1-\varepsilon)/e(G)$ as required. *

It is now easy to prove Section 1.1 from Lemma 5.1. See 1.1

Proof 5.3**.**

To evaluate $\textnormal{{Sample}}(G,\varepsilon)$, we first make $n$ into a power of two by adding at most $n$ isolated vertices to $G$; note that this does not impede the evaluation of $\textup{cIND}_{G}$. We then call $\textnormal{{HelperSample}}(G,\varepsilon/3)$. If it returns Fail, or does not return a value within $\mathcal{O}(nT)$ time and $\mathcal{O}(T)$ oracle queries, then we return Fail. Otherwise, we return its output. Writing $F$ for our output, by Lemma 5.1, for all $f\in E(G)$, we have $\mathbb{P}(F=f)\leq(1+\varepsilon)/e(G)$ and

[TABLE]

*as required. *

6 Corollaries of Sections 1.1 and 1.1

In this section, we restate and prove some fairly straightforward consequences of our main results, which allow us to turn decision algorithms for various problems in parameterised and fine-grained complexity into approximate counting and sampling algorithms.

See 1.1

Proof 6.1**.**

We may assume without loss of generality that $\varepsilon>n^{-k}$, since otherwise we can count or sample by brute force in time $\mathcal{O}(\varepsilon^{-1}T)$ by applying the (simulated) colourful independence oracle to each $k$-element subset of $V(G)$.

We next reduce the failure probability of $A_{G}$ with a standard probability amplification technique. Let $A_{G}^{\prime}$ be the algorithm with runs $A_{G}$ on the given inputs $\lceil 600k\log(n/\delta)\rceil$ times and returns the most common answer. By Lemma 2.4, the probability that this answer is incorrect is at most $2e^{-600k\log(n/\delta)/36}<(n/\delta)^{-14k}$, and each invocation of $A_{G}^{\prime}$ takes $\mathcal{O}(Tk\log n)$ time. We now simply run $\textnormal{{Count}}(G,\varepsilon,\delta/2)$ and $\textnormal{{Sample}}(G,\varepsilon/2)$ and return the results, using $A_{G}^{\prime}$ to simulate each call to the colourful independence oracle of $G$.

Recall the properties of Count and Sample from Sections 1.1 and 1.1. In both algorithms, $A_{G}^{\prime}$ is invoked $\mathcal{O}(\varepsilon^{-2}k^{7k}\log^{4k+11}n)$ times; by a union bound, for sufficiently large $n$, the probability it returns the correct answer on every invocation is at least

[TABLE]

*Conditioned on all oracle calls returning the correct answer, Count returns a valid $\varepsilon$-approximation with probability at least $1-\delta/2$ and Sample returns a valid $(\varepsilon/2)$-approximate sample. It follows by union bounds that without this conditioning, Count returns a valid $\varepsilon$-approximation with probability at least $1-\delta/2-n^{-10k}$, and Sample returns a valid $(n^{-10k}+\varepsilon/2)$-approximate sample with no possibility of failure. Since $(n/\delta)^{-10k}\leq\delta/2$ and $(n/\delta)^{-10k}\leq\varepsilon/2$, it follows that SampleCount behaves as desired. Moreover, by our running time bounds on Count, Sample and $A_{G}^{\prime}$, the running time of SampleCount is $\varepsilon^{-2}(k\log n)^{\mathcal{O}(k)}(n+T)$ as required. *

We believe that Section 1.1 does follow from a careful reading of the proofs of Sections 1.1 and 1.1 in the way one might expect, replacing all randomly-applied colourings of the graph by the colouring induced by $X_{1},\dots,X_{k}$. However, for the benefit of the reader, we give a slightly less efficient but far more easily-checkable algorithm by means of a standard colour coding argument.

See 1.1

Proof 6.2**.**

By Section 1.1, it suffices to simulate the colourful independence oracle of $G$ in time $(k\log n)^{\mathcal{O}(k)}(n+T)$. Let $X_{1},\dots,X_{k}\subseteq V(G)$ be an input to the colourful independence oracle of $G$, and let $X_{i,j}=X_{i}\cap V_{j}$ for all $i,j\in[k]$. Since $G$ is $k$-partite with vertex classes $V_{1},\dots,V_{k}$, every edge $e$ of $G[X_{1}\cup\dots\cup X_{k}]$ contains one vertex from each of $X_{1,\sigma_{e}(1)},X_{2,\sigma_{e}(2)},\dots,X_{k,\sigma_{e}(k)}$ for some map $\sigma_{e}\colon[k]\to[k]$. Moreover, $e$ is colourful under $X_{1},\dots,X_{k}$ if and only if $\sigma_{e}$ is a bijection. Motivated by this, for each bijection $\sigma:[k]\to[k]$, let $G_{\sigma}=G[X_{1,\sigma(1)}\cup\dots\cup X_{k,\sigma(k)}]$; then every colourful edge of $G$ appears in exactly one $G_{\sigma}$, and every edge appearing in any $G_{\sigma}$ is colourful. It follows that

[TABLE]

*We can compute each tuple $(X_{1,\sigma(1)},\dots,X_{k,\sigma(k)})$ in $\mathcal{O}(n)$ time, each oracle invocation takes $T$ time, and there are $k!$ such tuples to compute; thus overall we can compute $\mbox{cIND}_{G}(X_{1},\dots,X_{k})$ in $(k\log n)^{\mathcal{O}(k)}(n+T)$ time as required. *

Finally, we give a formal proof of Theorem 1.3, which is straightforward from Section 1.1 and Definition 1.1.

See 1.3

Proof 6.3**.**

Let $x$ be an instance of $\Pi$, and let $\varepsilon>0$. For all disjoint $X_{1},\dots,X_{k_{x}}\subseteq V(G_{x})$, we may compute $\mbox{cIND}_{G_{x}}(X_{1},\dots,X_{k_{x}})$ as follows:

1. (i)

Compute $I_{x}(X_{1}\cup\dots\cup X_{k_{x}})$ using the algorithm of Definition 1.1(iii); 2. (ii)

Run the assumed Colourful-$\Pi$* algorithm on $y=I_{x}(X_{1}\cup\dots\cup X_{k_{x}})$ with input partition $X_{1},\dots,X_{k_{x}}$ of $G_{y}=G_{x}[X_{1}\cup\dots\cup X_{k_{x}}]$.* 3. (iii)

Return $1$ if Colourful-$\Pi$* returns No and [math] if Colourful-$\Pi$ returns Yes.*

Denote this implementation by $A$. For brevity, let T^{+}(x)=\max\big{\{}T(I_{x}(S))\colon S\subseteq V(G_{x})\big{\}}; then $A$ has running time $\widetilde{\mathcal{O}}(|x|+T^{+}(x))$. Since $T^{+}(x)\geq T(x)=\widetilde{\Omega}(|x|)$ by hypothesis, $A$ therefore has running time $\widetilde{\mathcal{O}}(T^{+}(x))$.

Our algorithm now simply computes $V(G_{x})$ and $k_{x}$ from $x$ using the algorithm of Definition 1.1(ii), then returns $\textnormal{{SampleCount}}(V(G_{x}),k_{x},A,\varepsilon,2/3)$; by Corollary 1.1, this will yield an $\varepsilon$-approximation to $|E(G_{x})|$ and the desired $\varepsilon$-approximate sample from $E(G_{x})=W_{x}$ with the desired error probability. By Definition 1.1(i) we have $|E(G_{x})|=\#\Pi(x)$, and $E(G_{x})=W_{x}$ by definition, so the algorithm performs as required.

We now bound the running time. Observe from Definition 1.1(ii) that $n_{x}=\widetilde{\mathcal{O}}(|x|)$, and recall that by hypothesis we have $T^{+}(x)\geq T(x)=\widetilde{\Omega}(|x|)$; hence by Section 1.1, the overall running time is

[TABLE]

*as required. *

6.1 Application to Graph Motif

We now describe an approximate counting problem in parameterised complexity for which our results imply an immediate improvement over the best stated running time bound in the literature: the Graph Motif problem, introduced by Lacroix, Fernandes and Sagot [40] in the context of metabolic networks. This problem takes as input an $n$-vertex $m$-edge graph with a (not necessarily proper) vertex-colouring, together with a multiset $M$ of colours. We write $k=|M|$. A motif witness for $M$ is a set $U\subseteq V(G)$ of $k$ vertices such that the induced subgraph $G[U]$ is connected and the colour multiset of $U$ is exactly $M$. If $M$ has a motif witness, then $M$ is called a motif. Without loss of generality, let us assume that the set $C$ of allowed colours always satisfies $C=\{1,\dots,n\}$. The problem is formally stated as follows.

Graph Motif

Input: A graph $G$ on $n$ vertices and $m$ edges, a colouring ${c\colon V(G)\rightarrow C}$, and a multiset $M$ consisting of elements of $C$, with $|M|=k$.

Question: Is there a set $U\subseteq V(G)$ with $|U|=k$ such that $U$ induces a connected subgraph of $G$ and the multiset $\{c(u):u\in U\}$ is equal to $M$?

There has been substantial progress in recent years on improving the running-time of decision algorithms for Graph Motif [8, 13, 24, 31, 39]. Björklund, Kaski, and Kowalik [13] gave the fastest known randomised algorithm to solve (a generalisation of) this problem; in the following theorem, $\mu=\mathcal{O}(\log k\log\log k\log\log\log k)$ accounts for the time required to carry out arithmetic operations in a finite field of size $\mathcal{O}(k)$ and characteristic 2.

Theorem 6.4** (Björklund, Kaski, and Kowalik [13]).**

*There exists a Monte Carlo algorithm for Graph Motif that runs in $\mathcal{O}(2^{k}k^{2}m\mu)$ time and in polynomial space, with the following guarantees: (i) the algorithm always returns No when given a No-instance as input, (ii) the algorithm returns Yes with probability at least 1/2 when given a Yes-instance as input. *

For the counting version of Graph Motif, Guillemot and Sikora [31] addressed the related problem of counting $k$-vertex subtrees whose multiset of vertex colours equals $M$. This problem is equivalent to counting motif witnesses $U$ for $M$ weighted by the number of trees spanned by $U$. When $M$ is a set, this exact counting problem admits an FPT algorithm, but is #W[1]-hard otherwise. Subsequently, Jerrum and Meeks [35] addressed the more natural counting analogue of Graph Motif in which the goal is to count all motif witnesses for $M$ (without weights). They demonstrated that this problem is #W[1]-hard to solve exactly even if $M$ is a set, but gave an FPTRAS to solve it approximately. The goal in [35] was simply to demonstrate the existence of an FPTRAS rather than to optimise the running time; the algorithm as described has running time $\Omega(n^{3})$. We believe that, with sufficient care, the general strategy described in [35] could be adapted to give a running time similar to that obtained in the following corollary; however, Theorem 1.3 allows us to deduce this improvement immediately from Theorem 6.4. Moreover, it provides a method for translating any future improvement to the decision algorithm into an improved algorithm for approximate counting or sampling.

Corollary 6.5**.**

*Given an $n$-vertex, $m$-edge instance $(G,c,M)$ of Graph Motif with $k=|M|$ and $0<\varepsilon<1$, there is a randomised algorithm to $\varepsilon$-approximate the number of motif witnesses or to draw an $\varepsilon$-approximate sample from the set of motif witnesses in time $\varepsilon^{-2}k^{\mathcal{O}(k)}m\log^{\mathcal{O}(k)}n$. *

In order to apply Theorem 1.3, we need to show that Graph Motif is a uniform witness problem according to Definition 1.1. Given an instance $x=(G,c,M)$, we let $G_{x}$ be the $k$-hypergraph on the vertex-set $V(G)$ whose edges are all sets $U\subseteq V(G)$ that are motif witnesses for $M$. It is clear that $G_{x}$ satisfies the conditions of Definition 1.1 on taking $I_{x}(S)=(G[S],c|_{S},M)$, and so Graph Motif is a uniform witness problem. Another precondition of Theorem 1.3 is that any algorithm for the problem requires at least time $\widetilde{\Omega}(n)$; this is true for Graph Motif, because any algorithm for it must read a constant proportion of the input. Finally, before we can apply Theorem 1.3 to immediately obtain Corollary 6.5, we must state an algorithm for the problem Colourful-Graph Motif of Definition 1.2; to avoid confusion with the colouring that already exists, we instead call this Partitioned Graph Motif. It is clear that the maximum running time for this algorithm on any sub-instance will be dominated by that for the original instance.

Lemma 6.6**.**

*There exists a randomised algorithm for Partitioned Graph Motif that runs in time $k^{\mathcal{O}(k)}m$, with error probability at most $1/3$. *

Proof 6.7**.**

The input to Partitioned Graph Motif consists of $(G,c,M)$ and a partition of $V(G)$ into disjoint sets $S_{1},\dots,S_{k}$. We now describe an algorithm that decides whether there is a motif witness $U\subseteq V(G)$ that intersects each set $S_{i}$ in exactly one vertex.

Write $M=\{c_{1},\ldots,c_{k}\}$. For each possible bijection $\pi:[k]\rightarrow[k]$ we will determine, with probability at least $1-\frac{1}{3k!}$, whether there is a motif witness $U$ with $U=\{u_{1},\ldots,u_{k}\}\subseteq V(G)$ such that, for all $i\in[k]$, we have $u_{i}\in S_{i}$ and $c(u_{i})=c_{\pi(i)}$. We achieve this by solving a new instance $(G,c^{\prime},M^{\prime})$ of Graph Motif using the algorithm of Theorem 6.4: we use the same input graph, but define a new colouring $c^{\prime}:V(G)\rightarrow C\times[k]$, where $c^{\prime}(v)=(c,i)$ if and only if $c(v)=c$ and $v\in V_{i}$. Moreover, we set $M^{\prime}=\{(c_{\pi(1)},1),\ldots,(c_{\pi(k)},k)\}$. We silently replace $C\times[k]$ with $[n]$ by discarding unused colours and renaming the rest. To achieve the claimed success probability, it suffices to call the randomised algorithm for Graph Motif a total of $\lceil 3k\log k\rceil$ times, returning Yes if any of the calls returns Yes, and No otherwise.

We return Yes if any of our trials over all possibilities for $\pi$ returns Yes; otherwise we return No. By a union bound, the probability that we obtain the correct answer for all $k!$ choices of $\pi$ is at least 2/3, and in this case we output the correct answer.

*In total, we invoke the randomised Graph Motif algorithm $k!\lceil 3k\log k\rceil$ times, so the total running time is $\mathcal{O}(k!k\log k\cdot 2^{k}k^{2}m\log k\log\log k\log\log\log k)=k^{\mathcal{O}(k)}m$. *

Corollary 6.5 is now immediate from Lemma 6.6 and Theorem 1.3. (Recall that, for any $k$-colour $m$-edge instance $x=(G,c,M)$ of Graph Motif and any $S\subseteq V(G_{x})=V(G)$, we have $I_{x}(S)=(G[S],c|_{S},M)$; thus the maximum in the right-hand side of (1) is simply $k^{\mathcal{O}(k)}m$.)

6.2 Application to $k$-SUM

The $k$-SUM problem has been studied since the 1990s as it arises naturally in the context of computational geometry (see for example [28]), and it has become an important problem in fine-grained complexity theory [51]. For all integers $k\geq 3$, the $k$-SUM problem asks, given a set of integers, whether some $k$ of them sum to zero. Each $k$-subset of integers that does sum to zero is called a witness. While Kane, Lovett, and Moran [38] very recently developed almost linear-size linear decision trees for $k$-SUM, the fastest known algorithm for this problem still runs in time $\widetilde{\mathcal{O}}(n^{\lceil k/2\rceil})$. A running time of $n^{o(k)}$ as $k\to\infty$ is ruled out under the exponential-time hypothesis [46]. We prove that any sufficiently non-trivial improvement over the best known decision algorithm carries over to approximate counting and witness sampling.

For any integer $k\geq 3$, the $k$-SUM problem is stated formally as follows.

$k$-SUM

Input: A set $X$ of integers.

Question: Is there a set $S\subseteq X$ with $|S|=k$ such that $\sum_{x\in S}x=0$? We call such sets witnesses for $X$.

Observe that $k$-SUM is a uniform witness problem by Definition 1.1: The $k$-hypergraph has vertex set $X$, its edges are precisely the witnesses for $X$, and for all $S\subseteq X$, the instance $I_{X}(S)$ is simply $S$. Thus, the problem Colourful-$k$-SUM of Definition 1.2 is given as follows: The input consists of $k$ disjoint sets $X_{1},\dots,X_{k}$ of integers, and the goal is to determine whether there exist $x_{1}\in X_{1},\dots,x_{k}\in X_{k}$ such that $\sum_{i}x_{i}=0$. Note that any algorithm for Colourful-$k$-SUM requires time $\widetilde{\Omega}(|X|)$ to read the input.

In order to apply Theorem 1.3, we first reduce Colourful $k$-SUM to $k$-SUM with the following lemma (which is well-known folklore).

Lemma 6.8**.**

*If an $n$-integer instance of $k$-SUM can be solved in time $T(n)$, then there is an $\mathcal{O}(T(n))$-time algorithm for Colourful $k$-SUM. *

Proof 6.9**.**

Let $X_{1},\dots,X_{k}$ be the input for Colourful $k$-SUM. For each $i\in[k]$, define injections $f_{i}\colon\mathbb{Z}\to\mathbb{Z}$ by

[TABLE]

For all $i\in[k]$, let $Y_{i}=\{f_{i}(x)\colon x\in X_{i}\}$, and let $Y=Y_{1}\cup\dots\cup Y_{k}$. Now we run the assumed $k$-SUM decision algorithm on $Y$ and output the result. Preparing the set $Y$ and running the algorithm takes time $\mathcal{O}(n)+T(n)$. Since any algorithm for $k$-SUM must read a constant proportion of its input, we have $T(n)\geq\Omega(n)$; thus, the overall running time of this algorithm is $\mathcal{O}(T(n))$.

To prove correctness, let $x_{i}\in X_{i}$ for all $i\in[k]$ such that $\sum_{i}x_{i}=0$. Then

[TABLE]

*and so there are $k$ distinct numbers in $Y$ whose sum is zero. Conversely, suppose $y_{1},\dots,y_{k}\in Y$ are distinct numbers whose sum is zero. Then by the uniqueness of base-$(k+1)$ expansions, we must have $y_{i}\in Y_{\sigma(i)}$ for some permutation $\sigma\colon[k]\to[k]$; moreover, $\sum_{i}f_{\sigma(i)}^{-1}(y_{i})=0$. Thus $\{f_{\sigma(1)}^{-1}(y_{1}),\dots,f_{\sigma(k)}^{-1}(y_{k})\}$ is a witness for Colourful $k$-SUM as required. We conclude that the reduction is correct. *

The following corollary is now immediate from Lemma 6.8 and Theorem 1.3. (Recall that, for any $n$-element instance $X$ of $k$-SUM and any $S\subseteq V(G_{X})=X$, we have $I_{X}(S)=S$; thus the maximum in the right-hand side of (1) is simply $T(n)$.)

Corollary 6.10**.**

*Fix $k\geq 3$, suppose an $n$-integer instance of $k$-SUM can be solved in time $T(n)$, and write $W$ for the set of witnesses. Then there is a randomised algorithm to $\varepsilon$-approximate $|W|$, or draw an $\varepsilon$-approximate sample from $W$, in time $\varepsilon^{-2}\cdot\widetilde{\mathcal{O}}(T(n))$. *

6.3 Application to $k$-Orthogonal Vectors

As is standard, we abbreviate $k$-Orthogonal vectors to $k$-OV. The $k$-OV problem has connections to central conjectures in fine-grained complexity theory [1, 30]. Clearly, $k$-OV can be solved in time $O(N^{k}D)$ using exhaustive search. Gao et al. [30] stated the Moderate-Dimension $k$-OV Conjecture, which says that $k$-OV cannot be solved in time $O(N^{k-\varepsilon}\operatorname{poly}(D))$ for any $\varepsilon>0$. We show that every superlogarithmic improvement over exhaustive search for $k$-OV carries over to approximate counting and sampling of $k$-OV witnesses. Note that such an improvement is already known for 2-OV, namely 2-OV has an $N^{2-1/\mathcal{O}(\log(D/\log N))}$-time algorithm [3]. Chan and Williams [15] already generalised this 2-OV decision algorithm to an exact counting algorithm. For all integers $k\geq 2$, the $k$-OV problem is stated formally as follows.

$k$-OV

Input: Sets $X_{1},\dots,X_{k}$ of vectors from $\{0,1\}^{D}$.

Question: Do there exist $x_{1}\in X_{1},\dots,x_{k}\in X_{k}$ with $\sum_{j=1}^{D}\prod_{i=1}^{k}(x_{i})_{j}=0$? We call such tuples $(x_{1},\dots,x_{k})$ witnesses for $X_{1},\dots,X_{k}$.

We remark that the sum and product in the problem definition refer to the usual arithmetic operations over $\mathbb{Z}$. Observe that $k$-OV is a uniform witness problem according to Definition 1.1: for a $k$-OV instance $x=(X_{1},\dots,X_{k})$, the $k$-hypergraph $G_{x}$ has vertex-set $X_{1}\cup\dots\cup X_{k}$, its edges are precisely the witnesses of the $k$-OV instance, and for any $S\subset X_{1}\cup\dots\cup X_{k}$, the instance $I_{x}(S)$ is $(S\cap X_{1},\dots,S\cap X_{k})$. Notice that $k$-OV is in fact a colourful uniform witness problem, since $G_{x}$ is always $k$-partite, and so Colourful-$k$-OV reduces to $k^{\mathcal{O}(k)}$ instances of $k$-OV.

The following corollary is now immediate by Theorem 1.3, since any algorithm for $k$-OV requires time $\widetilde{\Omega}(|X_{1}\cup\dots\cup X_{k}|)$ to read the input and, by the definition of $I_{x}(S)$ and our choice of $T$, it is immediate that the maximum in the right-hand side of (1) is simply $T(x)$.

Corollary 6.11**.**

*Fix $k\geq 2$, suppose an $N$-vector $D$-dimensional instance of $k$-OV can be solved in time $T(N,D)$, and write $W$ for the set of witnesses. Then there is a randomised algorithm to $\varepsilon$-approximate $|W|$, or draw an $\varepsilon$-approximate sample from $W$, in time $\varepsilon^{-2}\cdot\widetilde{\mathcal{O}}(T(N,D))$. *

6.4 Application to first-order model checking

In this section, we apply our results to the property testing problem for $k\textrm{-FO}$. Informally, the input to this problem consists of a formula and a structure (e.g., the edge relation of a graph), to decide whether the formula is satisfiable in the structure, that is, whether there is an assignment to the free variables that makes the formula true. Correspondingly, the property counting problem is to count all satisfying assignments. In order to formally introduce this problem, we must introduce some standard notation from logic; for the convenience of the reader, we will also give a brief introduction to the associated concepts.

Syntax

The class $k\textrm{-FO}$ is the set of all first-order formulas $\varphi$ in prenex normal form with at most $k$ variables. Here is an example of a formula $\Phi\in 5$-FO:

[TABLE]

Because all the quantifiers are at the front, the formula is in prenex normal form. The formula $\Phi$ has free variables $x_{1},x_{2},x_{3}$ and uses two relation symbols $R_{1}$ and $R_{2}$. The arity of $R_{1}$ is $2$ and the arity of $R_{2}$ is $3$. Therefore, we say that $\Phi$ uses the vocabulary $\nu_{\Phi}=(R_{1},R_{2},2,3)$.

In general, a vocabulary is a tuple $\nu=(R_{1},\dots,R_{r},\alpha_{1},\dots,\alpha_{r})$, where $R_{1},\dots,R_{r}$ are relation symbols and $\alpha_{1},\dots,\alpha_{r}$ are positive integers denoting the respective arities of the relation symbols. A formula $\varphi\in k\textrm{-FO}{}$ over the vocabulary $\nu$ satisfies

[TABLE]

where the variables $x_{1},\dots,x_{\ell}$ are the free variables of $\varphi$, each $Q_{i}\in\{\exists,\forall\}$ is a quantifier, and $\psi$ is a quantifier-free Boolean formula over the variables $x_{1},\dots,x_{k}$ such that each atom of $\psi$ is of the form $R_{i}(x_{j_{1}},\dots,x_{j_{\alpha_{i}}})$, that is, each atom of $\psi$ applies some relation symbol $R_{i}$ to a tuple of $\alpha_{i}$ variables.

Semantics

So far, the formulas $\Phi$ and $\varphi$ only consist of syntax. In order to be able to say that a formula is satisfiable, we need to define a universe $U$ as well as instantiate the relation symbols with actual relations over $U$ of matching arities. In our example, we might set the universe to be $U_{\Phi}=\{a,b,c,d\}$. Then the variables of $\Phi$ take values from $U_{\Phi}$, and all quantification is over $U_{\Phi}$. We might then instantiate the relations via $\mathcal{R}_{1}=\{(a,b),(b,c)\}$ and $\mathcal{R}_{2}=\{(a,d,c)\}$. We say that $\mathcal{S}_{\Phi}=(U,\mathcal{R}_{1},\mathcal{R}_{2})$ is a structure for $\nu_{\Phi}$. Now we can see that $\Phi(a,b,c)$ is true and $\Phi(a,c,d)$ is false in the structure $\mathcal{S}_{\Phi}$, and that $\Phi$ is satisfiable in $\mathcal{S}_{\Phi}$ because it has at least the satisfying assignment $(a,b,c)$.

In general, a structure $\mathcal{S}=(U,\mathcal{R}_{1},\dots,\mathcal{R}_{r})$ for the vocabulary $\nu$ consists of a finite universe $U$ together with relations $\mathcal{R}_{1},\dots,\mathcal{R}_{r}$ over $U$ such that the arity of each $\mathcal{R}_{i}$ is equal to $\alpha_{i}$. An assignment $(y_{1},\dots,y_{\ell})\in U^{\ell}$ to the free variables of $\varphi$ is called satisfying in $\mathcal{S}$ if $\varphi(y_{1},\dots,y_{\ell})$ is true in the structure $\mathcal{S}$. For all positive integers $k$, we define the following problem.

$k\textrm{-FO}$ Property Testing

Input:

1. (i)

A vocabulary $\nu=(R_{1},\dots,R_{r},\alpha_{1},\dots,\alpha_{r})$ with $\alpha_{i}\leq k$ for all $i$, 2. (ii)

A structure $\mathcal{S}=(U,\mathcal{R}_{1},\dots,\mathcal{R}_{r})$ on $\nu$, where all tuples in all $\mathcal{R}_{i}$’s are explicitly given as a list and $\emptyset\neq\mathcal{R}_{i}\subseteq U^{\alpha_{i}}$ holds for all $i$, 3. (iii)

A first-order formula $\varphi$ in prenex normal form and with vocabulary $\nu$, free variables $x_{1},\dots,x_{\ell}$, and at most $k-\ell$ quantifiers.

Question: Does $\varphi$ have a satisfying assignment in $\mathcal{S}$?

Property testing is an important problem in logic and in database theory (cf. [23]). The fine-grained complexity of property testing has recently been studied to some extent [19, 30, 49]. In particular, Gao et al. [30] devise an algorithm for the property testing problem that runs in time $m^{k-1}/2^{\Theta(\sqrt{\log m})}$ for any fixed $k\textrm{-FO}$ formula, where $m$ is the number of distinct tuples in the input relations. This improves upon an already non-trivial $\widetilde{\mathcal{O}}(m^{k-1})$ time algorithm.

We prove the following reduction from approximate counting to decision.

Corollary 6.12**.**

*Fix $k\in\mathbb{Z}_{\geq 0}$, and suppose $k\textrm{-FO}$ Property Testing has an algorithm that runs in time $T(|\varphi|,n,m)$, where $|\varphi|$ is the size of the formula, $n$ is the size of the universe, and $m$ is the total number of tuples in the structure. Let $\mathcal{W}$ be the set of satisfying assignments. Then there is a randomised algorithm to $\varepsilon$-approximate $|\mathcal{W}|$, or draw an $\varepsilon$-approximate sample from $\mathcal{W}$, in time $\varepsilon^{-2}\cdot\widetilde{\mathcal{O}}(T(|\varphi|+\ell,n,m+n))$. *

This corollary follows from Theorem 1.3 by using the assumed algorithm for $k\textrm{-FO}$ Property Testing to simulate the uncoloured independence oracle of an appropriate hypergraph.

Proof 6.13**.**

In order to apply Theorem 1.3 to property testing, we need to show how $k\textrm{-FO}$ Property Testing is a uniform witness problem according to Definition 1.1. Let $x=(\nu,\mathcal{S},\varphi)$ be an instance of $k\textrm{-FO}$ Property Testing, let $\mathcal{S}=(U,\mathcal{R}_{1},\dots,\mathcal{R}_{r})$, and let $\ell$ with $\ell\leq k$ be the number of free variables in $\varphi$. We define the hypergraph $G=G_{x}$ as follows: For all $i\in\{1,\dots,\ell\}$, let $U_{i}=U\times\{i\}$. Define an $\ell$-hypergraph $G$ with vertex set $U_{1}\cup\dots\cup U_{\ell}$ whose edges are the sets $\{(y_{1},1),\dots,(y_{\ell},\ell)\}$ such that $(y_{1},\dots,y_{\ell})$ is a satisfying assignment of $\varphi$ in $\mathcal{S}$.

It is clear that this function $x\mapsto G_{x}$ satisfies the conditions (i) and (ii) of Definition 1.1. To prove that $k\textrm{-FO}$ Property Testing is a uniform witness problem, it remains to prove (iii). Indeed, let $X\subseteq V(G)$ be given as an input in addition to $x$. Then we prepare in time $\widetilde{\mathcal{O}}(|x|)$ an instance $I_{x}(X)=(\nu^{\prime},\mathcal{S}^{\prime},\varphi^{\prime})$ of $k\textrm{-FO}$ Property Testing such that $G_{I_{x}(X)}=G_{x}[X]$ holds: We set $X_{i}=X\cap U_{i}$ for all $i\in\{1,\dots,\ell\}$. We form the new instance $(\nu^{\prime},\mathcal{S}^{\prime},\varphi^{\prime})$ of $k\textrm{-FO}$ Property Testing as follows: form $\nu^{\prime}$ from $\nu$ by adding $\ell$ additional relation symbols $\in_{X_{1}},\dots,\in_{X_{\ell}}$, each with arity 1; form $\mathcal{S}^{\prime}$ from $\mathcal{S}$ by instantiating each $\in_{X_{i}}$ with the set $\{y\colon(y,i)\in X_{i}\}$; and form $\varphi^{\prime}$ from $\varphi$ by conjoining it with the formula $({\in_{X_{1}}}(x_{1})\wedge\dots\wedge{\in_{X_{\ell}}}(x_{\ell}))$. Then $G_{I_{x}(X)}=G_{x}[X]$ indeed holds. Thus, (iii) holds and $k\textrm{-FO}$ Property Testing is a uniform witness problem. In fact, since all hypergraphs involved are $k$-partite, it is a colourful uniform witness problem.

A technical precondition of Theorem 1.3 is that any algorithm for the problem requires at least time $\widetilde{\Omega}(|x|)$; this is true for $k\textrm{-FO}$ Property Testing, because any algorithm for it must read a constant proportion of the input. Since $k\textrm{-FO}$ Property Testing is a colourful uniform witness problem, we obtain an algorithm for Colourful-$\Pi$ with an overhead of only $k^{\mathcal{O}(k)}=\mathcal{O}(1)$ time. Thus, we can apply the theorem and obtain an algorithm for $\varepsilon$-approximate counting and sampling that runs in time

[TABLE]

*Since all instances $I_{x}(X)$ have a universe of size $n$, at most $n$ additional tuples, and a formula $\varphi^{\prime}$ that is $\varphi$ conjoined with $\ell$ additional terms, we have $T(I_{x}(X))\leq T(|\varphi|+\ell,n,m+n)$. The claimed running time then follows from $k=\mathcal{O}(1)$. *

By applying Corollary 6.12, we are able to lift the algorithm of Gao et al. [30], to approximate counting and sampling. For example, we obtain an algorithm to $\varepsilon$-approximately sample uniformly random satisfying assignments. For any fixed $k\textrm{-FO}{}$ formula $\varphi$, this algorithm runs in time $\varepsilon^{-2}m^{k-1}/2^{\Theta(\sqrt{\log m})}$. We remark the following subtleties: Gao et al. [30] state their algorithm for any fixed formula $\varphi$, but actually their algorithm is uniform in $\varphi$ with a running time that can be expressed as a product $f(|\varphi|)\cdot T(n,m)$. This means that increasing the size of $\varphi$ by a constant does not change the asymptotic running time for any fixed $\varphi$, since $f(|\varphi|+\ell)$ is constant as well. Finally, for certain quantifier structures of $\varphi$, they obtain even faster decision algorithms; since our reduction does not change the quantifier structure, these running times transfer to approximate counting and sampling as well.

6.5 Application to subgraph problems

Recall from the discussion following the statement of Section 1.1 that the theorem can be applied to the problem #$k$-Clique for every constant $k$. Thus, every $T(n)$-time algorithm to decide the existence of a $k$-clique can be turned into a $\widetilde{\mathcal{O}}(\varepsilon^{-2}T(n))$-time algorithm to $\varepsilon$-approximate the number of $k$-cliques. We now generalise this result to the problems of finding colourful or zero-weight copies of an arbitrary subgraph, and we obtain similar consequences for approximately uniform sampling via Section 1.1.

6.5.1 Colourful subgraphs

In this section, we use Section 1.1 to transform any decision algorithm for Colourful-$H$ into an approximate counting or sampling algorithm with roughly the same running time. For all graphs $H$ with $k$ vertices, the Colourful-$H$ problem is stated formally as follows.

Colourful-$H$

Input: A graph $G$ in adjacency list format and a vertex-colouring $c:V(G)\to[k]$ (not necessarily proper).

Question: Does $G$ contain a (not necessarily induced) subgraph $S$ such that $S$ is isomorphic to $H$ and, for all $i\in[k]$, there is some $v\in V(S)$ with $c(v)=i$?

Díaz, Serna, and Thilikos [20] use dynamic programming to solve Colourful-$H$ in time $\widetilde{\mathcal{O}}(n^{t+1})$, where $t$ is the treewidth of $H$ — their algorithm works for the exact counting version of the problem, too. Marx [42] asks, loosely speaking, whether the decision problem can be solved in time $n^{o(t)}$, and proves that $n^{o(t/\log t)}$ is impossible under the exponential-time hypothesis (ETH). For all constant $\gamma>0$, we show that a factor $n^{\gamma}$ improvement to Díaz et al.’s algorithm for the decision problem would immediately yield a corresponding improvement to the approximate counting or sampling problems.

Corollary 6.14**.**

*Let $H$ be any fixed graph. Suppose $n$-vertex $m$-edge instances of Colourful-$H$ can be solved by a randomised algorithm in time $T(m,n)$, and write $\mathcal{H}$ for the set of colourful $H$-subgraphs. Then there is a randomised algorithm to $\varepsilon$-approximate $|\mathcal{H}|$, or draw an $\varepsilon$-approximate sample from $\mathcal{H}$, in time $\varepsilon^{-2}\cdot\widetilde{\mathcal{O}}(T(m,n))$. *

In the proof, we use the notion of a graph homomorphism (see [41]). A function $f:V(H)\to V(G)$ is called a homomorphism if, for all $\{u,v\}\in E(H)$, we have $\{f(u),f(v)\}\in E(G)$. Note that injective homomorphisms correspond to subgraph embeddings.

Proof 6.15**.**

Let $(G,c)$ be an instance of Colourful-$H$. To motivate our proof, we first discuss a natural approach which fails. First, remove all edges $\{u,v\}\in E(G)$ with $c(u)=c(v)$ from the graph, and note that this makes $G$ $k$-partite with vertex classes $c^{-1}(1),\dots,c^{-1}(k)$ but does not change the answer. It would be natural to apply Theorem 1.3 to the $k$-partite $k$-hypergraph $\mathcal{G}$ on $V(G)$ in which $S\subseteq V(G)$ is an edge of $\mathcal{G}$ if $G[S]$ contains a subgraph isomorphic to $H$, and indeed when $H$ is a $k$-clique this approach works. However, in general each edge $S$ of $\mathcal{G}$ may correspond to more than one copy of $H$ contained in $G[S]$. Instead, we will apply Section 1.1 directly to count the edges in multiple $k$-hypergraphs corresponding to the $k!$ possible ways $H$ could be embedded as a subgraph in $G[S]$.

For each bijective function $d:V(H)\to[k]$, we let $\mathcal{G}_{d}$ be a $k$-hypergraph with vertex set $V(G)$ and edges given as follows. For each size-$k$ subset $S\subseteq V(G)$ with the property that $c|_{S}:S\to[k]$ is bijective (i.e. $S$ is colourful under $c$), we add $S$ to $E(\mathcal{G}_{d})$ if the function $(c|_{S}^{-1}\circ d):V(H)\to S$ is an injective homomorphism from $H$ to $G[S]$ (i.e. $G[S]$ contains $H$ as a subgraph with vertex colours matching $d$). We now claim

[TABLE]

where $\mathrm{Aut}(H)$ is the number of automorphisms of $H$. Observe that since $H$ is fixed, we have access to $\mathrm{Aut}(H)$; thus given the claim, the problem of $\varepsilon$-approximating $|\mathcal{H}|$ reduces to that of $\varepsilon$-approximating each term $e(\mathcal{G}_{d})$.

Proof of (25): We proceed by double-counting the number $N$ of injective homomorphisms $h\colon V(H)\to V(G)$ such that the image $h(H)$ is colourful in $G$ with respect to $c$, i.e. the number of ways $H$ can be embedded in $G$ as a colourful subgraph. On the one hand, each such $h$ has a unique image $S=h(V(H))\subseteq V(G)$ and a unique labelling $d\colon V(H)\to[k]$ such that $h=c|_{S}^{-1}\circ d$; thus it corresponds bijectively to the edge spanning $S$ in $\mathcal{G}_{d}$, and $\sum_{d}e(\mathcal{G}_{d})=N$. On the other hand, each copy of $H$ in $G$ corresponds to $\mathrm{Aut}(H)$ embeddings of $H$ into $G$, so we have $|\mathcal{H}|\mathrm{Aut}(H)=N$. Combining these two equations yields (25) as required.

**Approximating the terms: We will now $\varepsilon$-approximate each term $e(\mathcal{G}_{d})$ of the right-hand side of (25) using PartitionedSampleCount from Section 1.1 with $\delta=1/(3k!)$. By a union bound, the probability that at least one of the $k!$ invocations of PartitionedSampleCount fails is at most $1/3$. To approximate $e(\mathcal{G}_{d})$ using PartitionedSampleCount, we first recall that $\mathcal{G}_{d}$ is a $k$-partite $k$-hypergraph with explicitly given vertex classes, and then implement the uncoloured independence oracle for $\mathcal{G}_{d}$ using the assumed randomised decision algorithm for Colourful-$H$. To this end, we define the following algorithm $A(X)$:

On input $X\subseteq V(G)$, the algorithm constructs a graph $G^{\prime}$ on the vertex set $V(G^{\prime})=X$. Start with $G[X]$ and delete all edges internal to colour classes and all edges between colour classes whose corresponding vertices are not joined in $H$. (Conversely, we only add $\{u,v\}\in E(G[X])$ to $E(G^{\prime})$ if $\{d^{-1}(c(u)),d^{-1}(c(v))\}\in E(H)$ holds.) 2. 2.

Run the assumed algorithm for Colourful-$H$ on input $(G^{\prime},c^{\prime})$ where $c^{\prime}=c|_{V(G^{\prime})}$ and return its output.

Note that $A$ runs in time $\widetilde{\mathcal{O}}(n+m+T(m,n))$. Since any algorithm for Colourful-$H$ must read a constant proportion of the input vertices and edges, we have $T(n,m)=\Omega(n+m)$, so $A$ in fact runs in time $\widetilde{\mathcal{O}}(T(n,m))$. If $A$ implements the uncoloured independence oracle for $\mathcal{G}_{d}$ with error probability at most $1/3$, we can pass the description of this algorithm along with the vertex classes $X_{i}=X\cap c^{-1}(i)$ for all $i\in[k]$ and parameters $k$, $\varepsilon$, and $\delta=1/(3k!)$ to PartitionedSampleCount. Our running time bounds therefore follow, and it remains to prove correctness.

Correctness: First assume that $A(X)$ accepts, so that the goal is to show $e(\mathcal{G}_{d}[X])>0$. Because $A$ accepts, there is an $H$-isomorphic colourful subgraph $F$ of $(G^{\prime},c)$. Let $S=V(F)$. By the construction of $G^{\prime}$, all edges in $F$ must be between colour classes whose corresponding vertices are joined in $H$, so the function $c|_{S}^{-1}\circ d$ is an injective homomorphism from $H$ to $G^{\prime}[S]$. Thus $S\in E(\mathcal{G}_{d}[X])$, so $e(\mathcal{G}_{d}[X])>0$ as required.

For the reverse direction, suppose ${e(\mathcal{G}_{d}[X])>0}$. We need to show that $A(X)$ accepts with probability at least $2/3$. Let $S\in E(\mathcal{G}_{d}[X])$. Then by the definition of $\mathcal{G}_{d}$, the function $c|_{S}^{-1}\circ d$ is an injective homomorphism from $H$ to $G[S]$. By the construction of $G^{\prime}$, it is also an injective homomorphism from $H$ to $G^{\prime}[S]$, so $G^{\prime}$ contains a colourful $H$-subgraph and so $(G^{\prime},c)$ is a Yes instance. In this case, our assumed algorithm for Colourful-$H$, and hence also $A(X)$, accepts with probability at least $2/3$. We have proved correctness as required.

Sampling: Our sampling algorithm is very similar to our approximate counting algorithm, again using the fact that each subgraph corresponds to $\mathrm{Aut}(H)$ embeddings, so we omit the details. The only differences are the following:

We require that each invocation of our approximate counting algorithm has failure probability at most $\varepsilon/(10k^{2k}\ln(5/\varepsilon))$ and set $\delta$ accordingly. 2. 2.

Rather than outputting a weighted sum of $\varepsilon$-approximations of each $e(\mathcal{G}_{d})$, we use $(\varepsilon/10)$-approximations of each $e(\mathcal{G}_{d})$ to apply rejection sampling as in e.g. Florescu **[25, Proposition 3.3]**. Thus writing $N$ for our $(\varepsilon/10)$-approximation of $|\mathcal{H}|$ and $N_{d}$ for our $(\varepsilon/10)$-approximation of $e(\mathcal{G}_{d})$, we choose a bijective function $d\colon[k]\to[k]$ uniformly at random, take an $(\varepsilon/10)$-approximate sample from $E(\mathcal{G}_{d})$, and accept and output this sample with probability $N_{d}/N$; otherwise, we reject it and resample. If we require more than $k^{2k}\ln(5/\varepsilon)$ iterations, we return an arbitrary output.

*Note that the acceptance probability at each step is at least $1/(\mbox{Aut}(H)^{2})\geq 1/k^{2k}$, and acceptance is independent at each step, so the probability we require more than $k^{2k}\ln(5/\varepsilon)$ invocations is at most $(1-1/k^{2k})^{k^{2k}\ln(5/\varepsilon)}\leq\varepsilon/5$. Combining this with the error in the rejection sampling from our $(\varepsilon/10)$-approximations, and with the probability that our approximate counting algorithm fails to return a correct value in the first $k^{2k}\ln(5/\varepsilon)$ invocations (which is at most $\varepsilon/10$ by a union bound), we see that our algorithm returns an $\varepsilon$-approximate sample as required. Since $\varepsilon\geq n^{-k}$, the running time bound is immediate. *

6.5.2 Weighted subgraphs

In an edge-weighted graph, the graph $G$ is augmented with a function $w:E(G)\to\mathbb{Z}$. The weight $w(F)$ of a subgraph $F$ of $G$ is the sum $\sum_{e\in E(F)}w(e)$ of all edge-weights in $F$. We now consider the following computational problem for any fixed unweighted graph $H$.

Exact-Weight-$H$

Input: An edge-weighted graph $G$ with (perhaps negative) integer weights.

Question: Does $G$ have a subgraph isomorphic to $H$ with total weight zero?

The special case where $H$ is a $k$-clique has been studied in fine-grained complexity under the name Exact-Weight $k$-Clique. It has been conjectured [1] that there does not exist any real $\varepsilon>0$ and integer $k\geq 3$ such that the Exact-Weight $k$-Clique problem on $n$-vertex graphs and with edge-weights in $\{-M,\ldots,M\}$ can be solved in time $n^{(1-\varepsilon)k}\operatorname{polylog}(M)$. For the closely related Min-Weight $k$-Clique problem, only subpolynomial-time improvement over the exhaustive search algorithm is known [1, 50, 15], with a running time of $n^{k}/\exp(\Omega(\sqrt{\log n}))$. As we now show, Theorem 1.3 implies that any sufficiently non-trivial improvement on the running time of an Exact-Weight $k$-Clique algorithm will carry over to the approximate counting and sampling versions of the problem.

Corollary 6.16**.**

*Fix $k\geq 3$, suppose an $n$-vertex $m$-edge instance of Exact-Weight $k$-Clique with weights in $[-M,M]$ can be solved in time $T(n,m,M)$, and write $\mathcal{C}$ for the set of zero-weight $k$-cliques. Then there is a randomised algorithm to $\varepsilon$-approximate $|\mathcal{C}|$, or draw an $\varepsilon$-approximate sample from $\mathcal{C}$, in time $\varepsilon^{-2}\cdot\widetilde{\mathcal{O}}(T(n,m,M))$. *

Proof 6.17**.**

First observe that Exact-Weight $k$-Clique is a uniform witness problem by Definition 1.1: Given an instance $(G,w,k)$ of Exact-Weight $k$-Clique, we have $V(G_{x})=V(G)$ and the edges of $G_{x}$ are precisely the $k$-cliques of $G$, with $I_{(G,w,k)}(S)=(G[S],w|_{S},k)$ for all $S\subseteq V(G)$. Moreover, any randomised algorithm for Colourful-Exact-Weight $k$-Clique (see Definition 1.2) must read at least a constant proportion of the input bits, and so the lower bound on its running time required by Theorem 1.3 is satisfied. Hence, by Theorem 1.3, it suffices to give an algorithm for Colourful-Exact-Weight $k$-Clique with running time $\widetilde{\mathcal{O}}(T(n,m,M))$.

*Let $(G,w,k)$ be an instance of Exact-Weight $k$-Clique, and let $X_{1},\dots,X_{k}$ be a partition of $V(G)$. Then we form a graph $G^{\prime}$ from $G$ in linear time by removing all edges internal to each vertex set $X_{i}$, and apply our Exact-Weight $k$-Clique decision algorithm to $G^{\prime}$ in time at most $T(n,m,M)$. The cliques of $G^{\prime}$ are precisely the colourful cliques of $G$ with respect to $V_{1},\dots,V_{k}$, so this solves Colourful-Exact-Weight $k$-Clique in $\tilde{\mathcal{O}}(m+n+T(n,m,M))$ time as required. *

There is a generalisation of Exact-Weight $k$-Clique to edge-weighted $d$-hypergraphs, for which a fine-grained complexity conjecture exists [1]. A result analogous to Corollary 6.16 holds for this problem as well, but we do not state it formally.

Instead, we now state a more interesting corollary for Exact-Weight-$H$. When $H$ is a $k$-clique, it was sufficient in the proof of Corollary 6.16 to delete some edges to make sure that the colourful independence oracle only counts colourful copies of $H$. For general graphs $H$, we control this by relying on basic bit tricks that are commonly used in subset sum or exact-weight type problems. Unfortunately, we do not know how to do so inside the colourful independence oracle, at least not in the way in which we have formalised it. Instead, we perform an additional colour-coding step before running the algorithm of Section 1.1 as a black box, which leads to an additional $\varepsilon^{-2}$ factor overhead in the running time. However, we believe that this is merely an artefact that can be avoided by doing some surgery on the proofs of our main results. Since doing so would be lengthy, and does not add any insight, we accept the loss in the running time to get a cleaner proof.

Corollary 6.18**.**

*Let $H$ be any fixed graph with $k$ vertices. Suppose that $n$-vertex $m$-edge instances $G$ of Exact-Weight-$H$ with weights in $[-M,M]$ can be solved in time $T(m,n,M)$, and write $\mathcal{S}$ for the set of subgraphs of $G$ that are isomorphic to $H$. Then there is a randomised algorithm to $\varepsilon$-approximate $|\mathcal{S}|$, or draw an $\varepsilon$-approximate sample from $\mathcal{S}$, in time $\varepsilon^{-4}\cdot\widetilde{\mathcal{O}}(T(m,n,k^{2}M))$. *

Proof 6.19**.**

We first set out the approximate counting algorithm, and we suppose for simplicity that our decision algorithm is deterministic. Let $G$ be an instance of Exact-Weight-$H$, and let $k=|V(H)|$. If $n<k$, we return the correct answer [math]. If $H$ has exactly $i$ isolated vertices, we remove them from $H$, produce an estimate for the reduced graph, and multiply this estimate by $\binom{n-k+i}{i}$ to obtain the estimate for $H$. Thus, we can assume without loss of generality that $n\geq k$ and that $H$ has no isolated vertices. The algorithm now proceeds as follows:

Let $t=\varepsilon^{-2}\cdot 100e^{2k}$. For all $r$ from $1$ to $t$:

1. (a)

Sample a partition $V_{1}\cup\dots\cup V_{k}=V(G)$ uniformly at random. 2. (b)

For all bijective functions $\pi:[k]\to V(H)$:

1. i.

Define the graph $G_{r,\pi}$ by deleting from $G$ all edges $E(V_{i},V_{j})$ between parts $V_{i}$ and $V_{j}$ for which $\pi(i)\pi(j)$ is not an edge of $H$. 2. ii.

Define the $k$-partite $k$-hypergraph $\mathcal{G}_{r,\pi}$ with vertex set $V(G)$ such that each set $S\subseteq V(G)$ is an edge of $\mathcal{G}_{r,\pi}$ if and only if $G_{r,\pi}[S]$ is isomorphic to $H$, contains one vertex from each $V_{i}$, and is zero-weight with respect to $w$. 3. iii.

Call the algorithm PartitionedSampleCount from Section 1.1 on $\mathcal{G}_{r,\pi}$ with $\delta=1/(100tk!)$ and with error parameter $\varepsilon/3$ to obtain an estimate $N_{r,\pi}$ for the number of edges in $\mathcal{G}_{r,\pi}$. 2. 2.

Output the estimate $\sum_{r,\pi}N_{r,\pi}\cdot k^{k}/(tk!\cdot\operatorname{Aut}(H))$.

Here the scaling factor $k^{k}/(tk!\cdot\operatorname{Aut}(H))$ arises from the fact that a random $k$-colouring of a set of size $k$ is colourful with probability $k!/k^{k}$, each edge in our hypergraph corresponds to $\operatorname{Aut}(H)$ injective homomorphisms from $H$ to $G$, and we repeat the whole process $t$ times.

We will explain how to simulate the uncoloured independence oracles of the hypergraphs $\mathcal{G}_{r,\pi}$ (as required by PartitionedSampleCount) shortly. First, we argue for the correctness of the algorithm.

**Proving correctness given uncoloured independence oracles: Count is called $tk!$ times, and each invocation fails to produce an $(\varepsilon/3)$-approximation with probability at most $\delta$. By a union bound, this implies that, with probability at least $0.99$, all estimates $N_{r,\pi}$ are $(\varepsilon/3)$-approximations to the respective numbers $e(\mathcal{G}_{r,\pi})$ of edges in the hypergraphs $\mathcal{G}_{r,\pi}$. Conditioned on this event, the sum that is produced as output is thus an $(\varepsilon/3)$-approximation to $\sum_{r,\pi}e(\mathcal{G}_{r,\pi})\cdot k^{k}/(tk!\cdot\operatorname{Aut}(H))$. Let $s_{r}$ be the number of subgraphs of $G$ that are isomorphic to $H$, are zero-weight with respect to $w$, and are colourful with respect to $V_{1},\dots,V_{k}$. As in the proof of Corollary 6.14, each colourful zero-weight copy of $H$ corresponds to exactly $\mathrm{Aut}(H)$ terms in $\sum_{\pi}e(\mathcal{G}_{r,\pi})$, and so the algorithm produces an $\varepsilon/3$-approximation to $\sum_{r}s_{r}k^{k}/(tk!)$.

We now prove that $\sum_{r}s_{r}k^{k}/(tk!)$ is likely to be an $(\varepsilon/3)$-approximation to the total number $|\mathcal{S}|$ of zero-weight subgraphs of $G$ that are isomorphic to $H$. To do so, we first show that it is equal to $|\mathcal{S}|$ in expectation and then apply Hoeffding’s inequality to prove concentration. For any zero-weight subgraph $F$ of $G$ that is isomorphic to $H$, let $X_{r,F}\in\{0,1\}$ be the indicator random variable for the event that $F$ is a subgraph of $G[V_{1},\dots,V_{k}]$ in the $r$’th iteration (that is, the event that there is some $\pi$ with $V(F)\in E(\mathcal{G}_{r,\pi})$). Then $\mathbb{E}(X_{r,F})=k!/k^{k}$, so we have

[TABLE]

Since each $s_{r}$ lies in $[0,|\mathcal{S}|]$, it follows by Hoeffding’s inequality (Lemma 2.1) that

[TABLE]

By Stirling’s formula and our definition of $t$, it follows that

[TABLE]

Thus, with overall probability at least $4/5$, we have $(1-\tfrac{\varepsilon}{3})|\mathcal{S}|\leq\tfrac{k^{k}}{tk!}\sum_{r}s_{r}\leq(1+\tfrac{\varepsilon}{3})|\mathcal{S}|$.

We now note that for all $0<\varepsilon<1$, $(1-\varepsilon/3)^{2}>1-\varepsilon$ and $(1+\varepsilon/3)^{2}<1+\varepsilon$; hence an $(\varepsilon/3)$-approximation of an $(\varepsilon/3)$-approximation is an $\varepsilon$-approximation. It therefore follows by a union bound that with probability at least $2/3$, the output of our algorithm is an $\varepsilon$-approximation to $|\mathcal{S}|$. This completes our correctness analysis.

Implementing the uncoloured independence oracles: For each hypergraph $\mathcal{G}_{r,\pi}$, we will implement the uncoloured independence oracle using our assumed decision algorithm for Exact-Weight-$H$. Let $X\subseteq V(G)$; then we must determine whether $\mathcal{G}_{r,\pi}[X]$ contains an edge, i.e. whether $G_{r,\pi}[X]$ contains a subgraph which is isomorphic to $H$, is zero-weight with respect to $w$, and is colourful with respect to the partition $V_{1},\dots,V_{k}$. We cannot simply apply the decision algorithm to $G_{r,\pi}[X]$ with the same weight function $w$, because this algorithm may find zero-weight isomorphic copies of $H$ that are not colourful. To deal with this issue, we give $G_{r,\pi}$ a new weight function $w_{r,\pi}$ which will enforce colourfulness using standard bit tricks.

For each $i\in[k]$, let $X_{i}=X\cap V_{i}$. Let $h$ be the number of edges of $H$. We define the function $\iota:E(G)\to[h]$ as follows: We set $\iota(\{u,v\})=\iota$ for all $\{u,v\}\in E(G)$ with $u\in V_{i}$ and $v\in V_{j}$ such that $\{\pi(i),\pi(j)\}\in E(H)$ is the $\iota$’th edge of $H$ in lexicographic order. We define the edge weights of $G_{r,\pi}$ by $w_{r,\pi}(e)=w(e)+\delta_{r,\pi}(e)$ for all $e$, where

[TABLE]

Let $\phi$ be the canonical homomorphism from $G_{r,\pi}$ to $H$, that is, the function that maps vertices from $V_{i}$ to the vertex $\pi(i)$ in $H$.

We claim that for any subgraph $F$ of $G_{r,\pi}$ isomorphic to $H$, we have $w_{r,\pi}(F)=0$ if and only $w(F)=0$ and $F$ is colourful with respect to the partition $V_{1},\dots,V_{k}$. If this is true, then we can simulate the uncoloured independence oracle of $\mathcal{G}_{r,\pi}$ applied to a set $X$ by applying our decision algorithm to $G_{r,\pi}[X]$.

To prove the claim, first note that

[TABLE]

This latter sum has exactly $h$ summands, and each summand is either $(hM+1)(2h)^{\iota}$ for some $\iota\geq 2$, or it is $-(hM+1)\sum_{\iota=2}^{h}(2h)^{\iota}$. If $F$ is colourful, then $\phi$ maps every edge of $F$ to a distinct edge of $H$, so the summands that occur are all different and trivially cancel; we therefore have $w_{r,\pi}(F)=w(F)$ in this case.

Suppose instead that $F$ is not colourful, so that $\phi$ maps two distinct vertices $x$ and $y$ of $F$ to the same vertex $z$ of $H$. Since $\phi$ is a homomorphism, $x$ and $y$ are each joined to $d_{H}(z)$ colour classes out of $\{V_{1},\dots,V_{k}\}$ in $F$; moreover, by the construction of $G_{r,\pi}$, at most $d_{H}(z)$ of these classes are distinct. Since $H$ does not contain isolated vertices, we have $d_{H}(z)>0$ and so some colour class must appear in both $x$’s neighbourhood and $y$’s neighbourhood. In other words, $\phi$ must map two different edges $f,f^{\prime}$ of $F$ to the same edge $e$ of $H$; this implies there is some $\iota\in[h]$ such that $\phi$ maps no edges to the $\iota$’th edge of $H$. Thus, the summands on the right-hand side of (26) do not cancel, since for all $\iota\in[h]$ we have $h\cdot(2h)^{\iota}<(2h)^{\iota+1}$ and $(2h)^{\iota+1}-h\cdot(2h)^{\iota}>(2h)^{\iota}$, and so $w_{r,\pi}\neq 0$ as required. We have therefore successfully implemented the uncoloured independence oracle for $\mathcal{G}_{r,\pi}$, the missing ingredient in our algorithm.

**Bounding the running time: Our algorithm creates $tk!=O(\varepsilon^{-2})$ weighted graphs $G_{r,\pi}$ and calls PartitionedSampleCount once for each. By Section 1.1, this takes time $\widetilde{\mathcal{O}}(\varepsilon^{-4}(m+n))$ and makes $\widetilde{\mathcal{O}}(\varepsilon^{-4})$ queries to the independence oracle. Each query to the independence oracle takes time $T(n,m,k^{2}M)=\Omega(n+m)$. Combining these facts, we obtain an overall running time of $\widetilde{\mathcal{O}}(\varepsilon^{-4}T(n,m,k^{2}M))$ as claimed.

Sampling algorithm: Our sampling algorithm is very similar to our approximate counting algorithm, so we omit the details. The only differences are the following.

We take only a single uniformly random partition $V_{1}\cup\dots\cup V_{k}$ with associated graphs $G_{\pi}$ for every $\pi\colon[k]\to V(H)$. 2. 2.

We require that each invocation of our approximate counting algorithm has failure probability at most $\varepsilon/(\ln(5/\varepsilon)10k^{2k})$ and set $\delta$ accordingly. 3. 3.

Rather than outputting a weighted sum of $\varepsilon$-approximations of each $e(G_{\pi})$, we use $(\varepsilon/10)$-approximations of each $e(G_{\pi})$ to apply rejection sampling as in e.g. Florescu **[25, Proposition 3.3]**. Thus writing $N$ for our $(\varepsilon/10)$-approximation of $e(G)$ and $N_{\pi}$ for our $(\varepsilon/10)$-approximation of $e(G_{\pi})$, we choose a bijective function $\pi\colon[k]\to[k]$ uniformly at random, take an $(\varepsilon/10)$-approximate sample from $E(G_{\pi})$ using the PartitionedSampleCount algorithm from Section 1.1, and accept and output this sample with probability $N_{\pi}/N$; otherwise, we reject it and resample. If we require more than $k^{2k}\ln(5/\varepsilon)$ iterations, we return an arbitrary output.

*Note that the acceptance probability at each step is at least $1/k^{2k}$, and acceptance is independent at each step, so the probability we require more than $k^{2k}\ln(5/\varepsilon)$ invocations is at most $(1-1/k^{2k})^{k^{2k}\ln(5/\varepsilon)}\leq\varepsilon/5$. Combining this with the error in the rejection sampling from our $(\varepsilon/10)$-approximations, and with the probability that our approximate counting algorithm fails to return a correct value in the first $k^{2k}\ln(5/\varepsilon)$ invocations (which is at most $\varepsilon/10$ by a union bound), we see that our algorithm returns an $\varepsilon$-approximate sample as required. Since $\varepsilon\geq n^{-k}$, the running time bound is immediate. *

Corollary 6.18 can be combined with known, non-trivial decision algorithms for Exact-Weight-$H$. For example, Abboud and Lewi [2, Corollary 5] prove that Exact-Weight-$H$ can be solved in time $\widetilde{\mathcal{O}}(n^{\gamma(H)})$, where $\gamma(H)\geq 1$ is a graph parameter that is small whenever $H$ has a balanced separator. We obtain the following.

Corollary 6.20**.**

*Let $H$ be a fixed graph. When $\mathcal{S}$ denotes the set of zero-weight $H$-subgraphs of a given $n$-vertex graph $G$, there is a randomised algorithm to $\varepsilon$-approximate $|\mathcal{S}|$, or draw an $\varepsilon$-approximate sample from $\mathcal{S}$, in time $\widetilde{\mathcal{O}}(\varepsilon^{-4}n^{\gamma(H)})$. *