Computing Hitting Set Kernels By AC^0-Circuits

Given a hypergraph $H = (V,E)$, what is the smallest subset $X \subseteq V$ such that $e \cap X \neq \emptyset$ holds for all $e \in E$? This problem, known as the hitting set problem, is a basic problem in parameterized complexity theory. There are well-known kernelization algorithms for it, which get a hypergraph $H$ and a number $k$ as input and output a hypergraph $H'$ such that (1) $H$ has a hitting set of size $k$ if, and only if, $H'$ has such a hitting set and (2) the size of $H'$ depends only on $k$ and on the maximum cardinality $d$ of edges in $H$. The algorithms run in polynomial time, but are highly sequential. Recently, it has been shown that one of them can be parallelized to a certain degree: one can compute hitting set kernels in parallel time $O(d)$ -- but it was conjectured that this is the best parallel algorithm possible. We refute this conjecture and show how hitting set kernels can be computed in constant parallel time. For our proof, we introduce a new, generalized notion of hypergraph sunflowers and show how iterated applications of the color coding technique can sometimes be collapsed into a single application.


Introduction
The hitting set problem is the following combinatorial problem: Given a hypergraph H = (V, E) as input, consisting of a set V of vertices and a set E of hyperedges with e ⊆ V for all e ∈ E, find a set X ⊆ V of minimum size that "hits" all hyperedges e ∈ E, that is, e ∩ X = ∅. Many problems reduce to the hitting set problem, including the vertex cover problem (it is exactly the special case where all edges have size |e| = 2) and the dominating set problem (a dominating set of a graph is exactly a hitting set of the hypergraph whose hyperedges are the closed neighborhoods of the graph's vertices). The computational complexity of the hitting set problem is thus of interest both in classical complexity theory and in parameterized complexity theory.
The first result on the parameterized complexity of the hitting set problem was an efficient kernelization algorithm for this problem restricted to edges of cardinality three [16]. This was later improved to a kernelization for the d-uniform version (all hyperedges have size exactly d) [15], which is based on the so-called Sunflower Lemma [13]. We will later have a closer look at this algorithm; at this point let us just summarize its main idea by "repeatedly find sunflowers and replace them by their cores until there are no more sunflowers." The Sunflower Lemma tells us that this algorithm will stop only when the input graph has been reduced to a kernel. The just-sketched kernelization algorithm is highly sequential, but Chen et al. [11] have recently shown that it can be parallelized: Instead of reducing sunflowers one-at-a-time, one can replace all sunflowers in a hypergraph by their cores simultaneously in constant parallel time. This process only needs to be repeated d(H) = max e∈E |e| times, leading to a parallel algorithm running in time O(d(H)). However, there were good reasons to believe that this algorithm is essentially the best possible (we will later discuss them) and Chen et al. conjectured that the hitting set problem does not admit a kernelization algorithm running in constant parallel time (that is, in time completely independent of the input graph).
Our Contributions. In the present paper we refute the conjecture of Chen et al. and show that there is a constant parallel time kernelization algorithm for the hitting set problem: Let us stress at this point that the AC 0 -family from the theorem really has a size that is polynomial in the input length (no exponential or even worse dependency on the parameters) and has a depth that is completely independent of the input. The hypergraph H ′ has the same vertex set V as H -a feature shared by all hypergraphs considered in this paper that simplifies the presentation. However, since V is still "large," the circuit is not quite a kernelization algorithm. Fortunately, this is easy to fix by replacing the vertex set of H ′ by V ′ = e∈E ′ e, yielding the following corollary: There is a dlogtime-uniform AC 0 -circuit family that computes a kernel for every instance for p k,d -hitting-set.
The theorem and corollary imply that all problems that can be reduced to p k,d -hitting-set via a parameter-preserving AC 0 -reduction admit a kernelization computable by an AC 0 -circuit family. This includes p k -vertex-cover, which is just p k,d -hitting-set with d fixed at 2; p ktriangle-removal, where the objective is to remove at most k vertices from an undirected graph so that no triangles remain; and also p k,deg -dominating-set, where we must find a dominating set of size at most k in an undirected graph and we parametrize by k and the maximum degree of the vertices.
Our proof of the main theorem requires the development of two new ideas, which we believe may also be useful in other situations. The above-mentioned parallel kernelization algorithm for the hitting set problem with runtime O(d(H)) essentially does the following: "Repeat d(H) times: replace all sunflowers of size k + 1 by their cores" and the difficult task in each of the d(H) iterations is to find the sunflowers. It turns out that this can be done in constant parallel time using the color coding technique [2] and it has been shown in [3] and again in [11] that this technique can be implemented in constant time. Our first idea for turning the circuits depth from O(d) into O(1) is to collapse the color codings from the d rounds into a single application of the color coding technique: Instead of applying color coding in each round to filter and describe "objects," we would like to apply one global application of color coding that already contains the internal colorings and does away with the intermediate objects.
Unfortunately, there does not appear to be a simple (or any) way of actually collapsing the colorings used when we "replace all sunflowers by their cores": The coloring coding technique is good at imposing requirements of the form "these objects must be disjoint," but cannot impose requirements of the form "these objects must be the same." For this reason, as our second new idea, we develop a generalization of the notion of a sunflower (which we dub "pseudo-sunflowers") that is tailored to the collapsing of color coding.
Related Work. The sequential kernelization algorithm for the hitting set problem based on the Sunflower Lemma has been known for a longer time [15], but there have been recent improvements that bring down the runtim to linear time [17]. A parallel version has recently been studied by Chen et al. [11] and they show how kernels for p k,d -hitting-set can be computed by circuits of depth O(d(H)). Chen et al. also conjecture that the circuit depth of O(d(H)) is unavoidable (which we refute).
The results of this paper fit into the larger, fledgling field of parallel parameterized complexity theory, which has already been studied both from a practical [1] and a theoretical point of view [8]. First results go back to research on parameterized logarithmic space [7,10,14], since it is known from classical complexity theory that problems that are solvable with such a resource bound can also be parallelized. A more structured analysis of parameterized space and circuit classes was later made by Elberfeld et. al [12], which addresses parallelization more directly. Current research on parameterized parallelization -including this paper -focuses on constanttime computations, that is, on a parameterized analogue of AC 0 [9,11,3,4]. We remark that many previous results (including several of the authors) boil down to showing that instead of using a known reduction rule many times sequentially, one can simply apply it in parallel "everywhere," but "only once." In contrast, the kernelization algorithm developed in the present paper had no previous counterpart in the sequential setting.
Organization of This Paper. After a short section on preliminaries, in Section 3 we review known kernelization algorithms for the hitting set problem -both the sequential ones and the parallel one. In Section 4 we discuss the obstacles that must be surmounted to turn the known parallel algorithm into one that needs only constant time. Towards this aim, we introduce the notions of pseudo-cores and pseudo-sunflowers as replacements for the cores and sunflowers used in the known algorithms. In Section 5 we then argue that these pseudo-sunflowers can be computed in constant time by "collapsing" multiple rounds of color coding into a single round. Full proofs can be found in the full version of the paper [5].

Preliminaries
A hypergraph is a pair H = (V, E) such that for all hyperedges e ∈ E we have e ⊆ V . We write V (H) = V and E(H) = E for the vertex and hyperedge sets of H. Let d(H) = max e∈E |e|. Throughout this paper, all hypergraphs will always have the same vertex set V , which is the input vertex set. For this reason, in slight abuse of notation, for two hypergraphs H 1 = (V, E 1 ) and H 2 = (V, E 2 ) we also write H 1 ⊆ H 2 for E(H 1 ) ⊆ E(H 2 ) and H 1 ∪H 2 for (V, E(H 1 )∪E(H 2 )).
Concerning circuit classes and parallel computations, we will only need the notion of ACcircuit families, which are sequences C = (C 0 , C 1 , C 2 , . . . ) of Boolean circuits where each C i is a directed acyclic graph whose vertices are gates such that there are i input gates, the inner gates are ∧-gates or ∨-gates with unbounded fan-in, or ¬-gates; and the number of output gates is either 1 (for decision problems) or depends on the number of input gates (for circuits computing a function). The size function S maps circuits to their size (number of gates) and the depth function D maps them to their depth (longest path from input gates to output gates). When D(C n ) ∈ O(1) and S(C n ) ∈ n O(1) hold, we call C an AC 0 -circuit family. Concerning circuit uniformity, all circuit families in this paper will be dlogtime uniform, which is the strongest notion of uniformity commonly considered [6]: there is a dtm that on input of bin(i)# bin(n), where bin(x) is the binary encoding of x, outputs the ith bit of a suitable encoding of C n in at most O(log n) steps.
Even though this paper is about a parallel kernelization algorithm, we will need only little from the machinery of parallel parameterized complexity theory. We do need the following notions: A parameterized problem is a pair (Q, κ) where Q ⊆ Σ * is a language and κ is a function κ : Σ * → N that is computable by a dlogtime-uniform AC 0 -circuit family. When we write down a parameterized problem such as p k,d -hitting-set, the indices of "p" (for "parameterized") indicate which parameter function κ we mean. A kernelization for a parameterized problem (Q, κ) is a function K that maps every instance x ∈ Σ * to a new instance K(x) ∈ Σ * such that for all x ∈ Σ * we have (1) x ∈ Q ⇐⇒ K(x) ∈ Q and (2) |K(x)| ≤ f (κ(x)) for some fixed computable function f .
A parameterized problem (Q, κ) lies in FPT if x ∈ Q can be decided by a sequential algorithm running in time f (κ(x)) · |x| O(1) for a computable function f . The AC 0 -analogue of FPT is the class para-AC 0 . It contains all problems (Q, κ) for which there is a circuit family (C n,k ) n,k∈N such that for all inputs x we have C |x|,κ(x) (x) = 1 if, and only if, x ∈ Q, and D(C n,k ) ∈ O(1) and S(C n,k ) ∈ f (k) · n O(1) . It is well-known that (Q, κ) ∈ FPT holds if, and only if, Q is decidable and there is a kernelization for (Q, κ) that is computable in polynomial time. The same proof as for the polynomial-time case also shows that we have (Q, κ) ∈ para-AC 0 if, and only if, Q is decidable and (Q, κ) has a kernelization that can be computed by an AC 0 -circuit family. (We stress once more that this means that the kernelization is a normal AC 0 -circuit family, having size S(C n ) ∈ n O(1) .) We will use the color coding technique a lot. First introduced in [2], it has recently been shown to work in the context of constant time computations [3,11]. The key observation underlying this technique is the following: Suppose we are given a set of n elements and suppose you have k special elements x 1 , . . . , x k together with some specific colors c 1 , . . . , c k for them "in mind". Then we can compute a set Λ of "candidate colorings" of all elements of the set such that at least one λ ∈ Λ colors each "in mind" vertex x i with the "desired" color c i , that is λ(x i ) = c i . Formally, the following holds (the original version of this lemma due to Alon et. al [2] is equivalent to the statement below -only without any depth guarantees): [3]). There is a dlogtime-uniform family (C n,k,c ) n,k,c∈N of AC-circuits without inputs such that each C n,k,c . has size at most O(log c · c k 2 · k 4 · n log 2 n).

Known Sequential Kernelization Algorithms
The knwon sequential kernelization algorithms for p k,d -hitting-set are based on the so-called Sunflower Lemma. The perhaps simplest application of this lemma is to repeatedly collapses sufficiently large sunflowers to their cores until there are no longer any large sunflowers in the graph and, then, the Sunflower Lemma tells us that the graph "cannot be very large." In detail, the definitions and algorithm are as follows: Definition 3.1 (Sunflower). A sunflower S with core C is a set of proper supersets of C such that for any two distinct p, q ∈ S we have p ∩ q = C. The elements of a sunflower are called petals. A sunflower in a hypergraph is a sunflower whose petals are hyperedges of the hypergraph.
The importance of the Sunflower Lemma for the hitting set problem lies in the following observation: Suppose a hypergraph H contains a sunflower S of size at least k + 1. Then H has a size-k hitting set if, and only if, the hypergraph obtained from H by removing all petals of the sunflower and adding its core has such a hitting set (we cannot hit the k + 1 petals in the sunflower using only k vertices without using at least one vertex of the core; thus, we hit all petals if, and only if, we hit the core). In other words, replacing a sunflower of size k + 1 by its core is a reduction rule for the hitting set problem; and if we can no longer apply this rule, the Sunflower Lemma tells us that the hypergraph's size is bounded by a function that depends only on k and d(H) -in other words, it is a kernel.
The just-described kernelization algorithm is simple, but "very sequential." It is, however, not too difficult to turn it into a more parallel algorithm -at least, as long as d(H) is fixed. This was first noted by Chen et al. [11] and we explain the ideas behind their proof below, rephrased for the purposes of the present paper.
A better sequential kernelization algorithm has recently [17] been proposed (it runs in time O(2 d(H) |E|), which is linear from a parameterized point of view) -but the algorithm is arguably "even more sequential" and does not lend itself to easy parallelization.

Known Parallel Kernelization Algorithm
The first step towards a parallel kernelization is the observation that we can compute many cores in parallel. Given a hypergraph H = (V, E) and a number k, let a k-core in H be a core C of a sunflower in H with more than k petals. Let k -cores(H) = V, {C | C is a k-core in H} . While in the sequential algorithm we always replace one sunflower by its core, we now replace all sunflowers by their cores. This leaves behind some hyperedges, but the Sunflower Lemma will show that their number is "small." Unfortunately, the set of cores itself may still be large and we need to apply the replace-all-sunflowers-by-cores operation repeatedly. This process does stop after at most d(H) rounds since the size of the cores decreases by 1 in each round and, hence, after d(H) rounds it has shrunk to 0. Let us now formalize these ideas a bit: Let H 0 = H and let H i+1 = k -cores(H i ). Then H 0 is the original hypergraph; H 1 is the set of its k-cores; H 2 is the set of H 1 's k-cores and thus the set of "cores of cores" of H; next H 3 is the set of "cores of cores of cores" of H; and so on, see Figure 1 for an example. In a sense, each H i is nested into the previous hypergraph, leading to a whole sequence resembling a matryoshka doll. Below, we define a matryoshka sequence as a sequence that has this "nested in some sense" property and then show in Lemma 3.4 that (H 0 , H 1 , . . . ) is, indeed, such a matryoshka sequence:   Proof. The first property of a matryoshka sequence is true by definition. The second property follows since each time we apply the operator k -cores to a hypergraph, the maximum size of the hyperedges decreases by at least 1 (cores are smaller than the largest petals of their sunflowers).
For the third property we actually even have equality here by definition. The last property is proved by induction on i. The case i = 0 is trivial, so consider a hitting set X of size k for H i−1 and consider a k-core C of H i−1 . By definition there must be a sunflower Recall that the idea behind the parallel computation of a kernel for the hitting set problem is to repeatedly remove all sunflowers from H, each time perhaps leaving a manageable number of hyperedges -and after d rounds, no hyperedges will remain. We use the following notation for the "removal" operation: For two hypergraphs H = (V, E) and that is, we remove all hyperedges from H that contain a hyperedge of H ′ . Thus, H ⊖ H 1 is the set of all hyperedges in H that are not involved in any sunflower of size at least k + 1 since we remove all edges that contain a core.
The following theorem shows that the repeated removing operation only leaves behind a "small" number of hyperedges. We formulate the theorem for arbitrary matryoshka sequences (we will need this later on), but it is best to think of the M i as the sets H i . Proof. For the first item, fix an i and consider M i ⊖ M i+1 . We claim that these "remaining hyperedges" cannot contain a sunflower {e 1 , . . . , e k+1 }: If it did, by the third property of a matryoshka sequence the sunflower's core would be an element of M i+1 and, thus, none of the e i would be in M i ⊖ M i+1 . By the Sunflower Lemma and the fact that d(

Then K has at most
This means that the union K cannot have more hyperedges than the sum of these numbers for i ∈ {1, . . . , d(H)} plus the number of hyperedges in M d(H) . However, by the second property we have d(M d(H) ) ≤ 0 and, thus, this hypergraph can contain at most one edge (the empty edge). We account for this single edge by the value For the second item, we make a simple observation: Let A, B, and C be hypergraphs (all with the same vertex set V as always) such that every size-k hitting set of A ∪ B is also a hitting set of C. We claim that To see this, first consider a size-k hitting set X of A ∪ B. Trivially, X is also a hitting set of A ∪ (B ⊖ C) ⊆ A ∪ B and X is also hitting set of C by assumption. Now, second, consider a size-k hitting set X of A ∪ (B ⊖ C) ∪ C. Trivially, X hits all of A as well as all hyperedges in B that are in B ⊖ C, so consider an edge e ∈ B − (B ⊖ C). By definition, this means that e must be a superset of some e ′ ∈ E(C) and X was a hitting set for C and, thus, hits e ′ and therefore also e.
Let us now prove the second item by proving by induction on i that H and have the same size-k hitting sets. The base case i = 0 is true by the first property of a matryoshka sequence. For the inductive step from By the inductive assumption, H and A ∪ B have the same size-k hitting sets. The fourth property of a matryoshka sequence now implies that every size-k hitting set of A ∪ B is also a hitting set of C. By ( * ) we get that A ∪ B has the same size-k hitting sets as Thus, H and A ∪ (B ⊖ C) ∪ C have the same size-k hitting sets, which was exactly the inductive claim for i + 1.
Instantiating the theorem with (H 0 , . . . , H d(H) ) tells us that, if we can compute the elements in parallel, we can compute a kernel for the hitting set problem in parallel. Clearly, "computing K" essentially boils down to "computing the H i " in parallel. Thus, the real question, which we address next, is how quickly and easily we can compute the hypergraphs H i .
At this point, we briefly need to address some technical issues concerning the coding of hypergraphs. For our purposes, it is largely a matter of taste how the input hypergraph H 0 is encoded, but the encoding of the later graphs H i becomes important in the context of parallel constant-time computations. We consider H = (V, E) fixed and encoded using, for instance, an incidence matrix (having |V | columns and |E| rows). We encode a refinement of H, that is, a hypergraph H ′ = (V, E ′ ) with the property that each e ′ ∈ E ′ is a subset of some e ∈ E, using a matrix of 2 d(H) columns and |E| rows. There is a column for each of the at most 2 d(H) possible subsets of an edge e ∈ E and the entry at the column for a given row is 1 if this subset is an element of E ′ ; otherwise it is 0. Let us call this the refinement matrix enconding of hypergraph H ′ (with respect to the fixed input hypergraph H).
Proof. By the definition of refinement matrix encodings, it suffices to show how we can decide for a single set e ′ ⊆ e ∈ E whether it is a hyperedge of H i+1 or not using a circuit of constant depth and size f (k, d) · |V | O(1) |E| O(1) -it then follows that we can do this for all possible e ′ in parallel without increasing the circuit depth at all and without increasing the circuit size by more than 2 d |E|.
Thus, "all" we need to test is whether there are petals p 1 , . . . , p k+1 ∈ E i that form a sunflower in H i with core e ′ . This question can be answered very quickly in parallel using color coding as follows: The vertices from the Color Coding Lemma (Fact 2.1) that we "have in mind" are the vertices in the petals and the color "we have in mind for them" is i for all vertices in p i − e ′ . Formally, we use Fact 2.1 to obtain a set Λ of colorings λ : V → {1, . . . , k + 1} and check whether for one of these colorings for each j ∈ {1, . . . , k + 1} there exists a hyperedge p j ∈ E i with the properties that (1) p j ⊇ e ′ and (2) all vertices in p j − e ′ have the color j. Clearly, such a coloring together with the hyperedges p 1 to p k+1 exists if, and only if, e ′ is the core of a sunflower of size k + 1 in H i . Even more importantly, Fact 2.1 provides us with such a coloring λ -if it exists -via a circuit of constant depth and size at most some polynomial in the number |V | of vertices times a computable function f (k, d) depending on the number k + 1 of colors and the maximum number d(k + 1) of vertices in the sunflower (for which we "had colors in mind").
The lemma tells us that once we have computed some H i , we can compute the next H i+1 using only constant additional depth and using f (k, d) · |V | O(1) |E| O(1) additional size. Since H i ⊖ H i+1 can easily be computed from H i and H i+1 in constant depth, we get:

Pseudo-Cores and Pseudo-Sunflowers
The parallel kernelization algorithm described in the previous section has a depth that is linear in the parameter d, the maximum size of any hyperedge in the input hypergraph. The reason for this linear dependency was that, while we managed to reduce not just one but all sunflowers in the hypergraph to their cores in parallel, we had to repeat this "reduce to core" procedure d times -and each round adds a constant number of layers to the circuit.
It is not obvious how this build-up of layers can be avoided. In the following, we first explain why there are good reasons to believe that the computation of the hypergraphs H i necessitates deeper and deeper circuits. Following this discussion, we explain our proposal for side-stepping these difficulties: we replace the hypergraphs H i by new hypergraphs H ′ i that are easier to compute but still form a matryoshka sequence and -hence -can serve as a replacement for the H i in the Kernel Theorem, Theorem 3.5.
The Difficulty: Cores of Cores Are Hard to Compute There are several reasons to believe that one cannot compute kernels for the hitting set problem in constant depth using the repeated sunflower-reduction-procedure. A first idea for reaching a constant depth is to apply the reduction procedure only a constant number of times (instead of d times). Indeed, it is not immediately clear that a "core of cores" is not already a core in the first round -so do we actually need more than one round? Unfortunately, the answer is "yes, we do": Figure 1 shows an example where {a, b} is a 2-core of the 2-cores, but it is not a 2-core of the original hypergraph. For a more complex example, where d rounds are needed to arrive at a constant size kernel, consider the trees T ℓ d (defined in detail later on) that are perfectly balanced trees of depth d with ℓ + 1 children per node for a number ℓ ≥ k -and now consider the hypergraph H d that has one hyperedge for each leaf of T ℓ d and this hyperedge contains all the nodes on the path from the leaf to the root r. Now, for i > 0 we have k -cores(H i ) = H i−1 and the latter hypergraphs all have a size of at least the arbitrarily large ℓ for i > 1. Thus, we need to apply the "core of cores" procedure at least d − 1 times before arriving at a hypergraph whose size depends only on the parameter.
A second, more promising idea is the observation that it might be possible to somehow "collapse" two (and then, hopefully, all) applications of the sunflower-reduction-procedure "into a single application." Unfortunately, we also run into a problem here, namely in the "collapsed color coding process." In essence, color coding is great at ensuring that certain vertex sets are disjoint (namely those vertex sets that receive different colors), but fails at enforcing that the same vertices are used in different hyperedges -which is exactly what is needed when the definition of some H i refers to H i−1 , which in turn refers to some H i−2 .
These problems with avoiding the build-up of additional layers with rising d have led Chen et al. [11] to the conjecture that the build-up is unavoidable and that all parallel kernelization algorithms for p k,d -hitting-set have a runtime that is linear in d. We agree with Chen et al. in their assessment that the computation of the H i presumably necessitates a linear circuit depth -but, nevertheless, we will refute their conjecture in the following.
The Solution: Pseudo-Cores As a Replacement For Cores Our idea is not to compute the sets H i (we do not see how this can be done in constant time), but to compute hypergraphs H ′ i with rather similar properties (formally, they will form matryoshka sequences as well) that we can compute in constant time for all d and i. We introduce a new notion of k-pseudo-cores of level i and H ′ i will be the hypergraph whose edges are the k-pseudo-cores of level i. Crucially, the definition of H ′ i (only) refers directly to the original input graph H and its hyperedges can be obtained from H directly using color coding. At the same time, the H ′ i will form a matryoshka sequence and, hence, just as for the H i , the core of any sunflower of H ′ i−1 must already be present in H ′ i . The definition of pseudo-cores is somewhat technical. We will, however, show that all cores are pseudo-cores of level 1, cores of cores are pseudo-cores of level 2, and so on. The reverse implication does not hold (for instance, pseudo-cores of level 2 need not be cores of cores). For a "level" L and a number k, let T k L denote the rooted tree in which all leafs are at the same depth L and all inner nodes have exactly k + 1 children. The root of T k L will always be called r in the following. Thus, T k 1 is just a star consisting of r and its k + 1 children, while in T k 2 each of the k + 1 children of r has k + 1 new children, leading to (k + 1) 2 leafs in total. For each l ∈ leafs(T k L ) = { l | l is a leaf of T k L } there is a unique path (l 0 , l 1 , . . . , l L ) from l 0 = r to l L = l. An example for the following definition is shown in Figure 2.  The four properties of pseudo-sunflowers hold: In "column S(l, 0)" we always have the pseudo-core, the union of each row is a hyperedge, the sets in a row form a partition of this hyperedge, and -most importantly -we have the disjointness property at each "branch" of the tree. This property requires that for column S(l, 1) the sets of all red vertices, of all blue vertices, and of all green vertices are pairwise disjoint; whereas for column S(l, 2) it requires that the three red sets are pairwise disjoint, likewise for the three blue sets, and the three green sets. However, it is permissible (and the case) that a red vertex in the third column is the same as green vertex in the third or the second column. To get some intuition, let us have a closer look at H ′ 1 . As the following lemma shows, pseudocores and cores are still very closely related at this first level -while for larger levels, we no longer have Proof. Consider a k-pseudo-core of H of level 1. The tree T k 1 consists of a root r with leafs l 1 to l k+1 . Consider a T k 1 -pseudo-sunflower S and let us fix some leaf l of T k 1 . The pseudo-sunflower must map (l, 0) to the pseudo-core C and (l, 1) to a set of vertices that is disjoint from C. This means that S(l) = S(l, 0) ∪ S(l, 1) = C ∪ S(l, 1) ∈ E is a hyperedge in H that contains the (pseudo)core C. Furthermore, for any two different leafs l and m we have S(l, 1) ∩ S(m, 1) = ∅ or, equivalently, S(l) ∩ S(m) = C. This shows that {S(l 1 ), . . . , S(l k+1 )} is a sunflower with core C. For the other direction, given a sunflower {e 1 , . . . , e k+1 } of size k + 1 in H with core C, the T k 1 -pseudo-sunflower S given by S(l i , 0) = C and S(l i , 1) = e i − C, where the l i are the k + 1 leafs of T k 1 , witnesses that C is also k-pseudo-core of level 1 of H.

The Constant-Depth Kernelization
We show that hitting set kernels can be computed in constant depth in two steps: 1. We show that (H ′ 0 , . . . , H ′ d(H) ) is a matryoshka sequence.

We show that all H ′ i can be computed by a constant depth circuit whose depth is independent of both k and d(H).
By the Kernel Theorem, Theorem 3.5, taken together, these two items yield the desired kernelization algorithm.
Step 1: Pseudo-Cores Form Matryoshka Sequences. Our first aim is to show the following theorem, which is an analogue of Lemma 3.4 for pseudo-cores: The proof consists of four lemmas, one for each of four properties of a matryoshka sequence: Proof. By definition. there must now be a T k L -pseudo-sunflower S j with pseudo-core e j . From these k + 1 different pseudo-sunflowers, we construct a T k L+1 -pseudo-sunflower S whose pseudo-core is e as follows: In the tree T k L+1 , let c 1 to c k+1 be the children of the root r. For a leaf l of T k L+1 , let l 1 = c j be the child of r on the path from r to l and let us view l also as a leaf in the tree T k L rooted at c j . We define S as follows: 1. S(l, 0) = e.
It remains to show that the mapping S defined in this way satisfies the four properties of a pseudo-sunflower. Consider any two leafs l and m of T k L+1 : 1. By definition, S(l, 0) = e and, thus, e is the pseudo-core of S.
2. S(l, 0)∪S(l, 1)∪· · ·∪S(l, L+1) = e∪(e j −e)∪S j (l, 1)∪· · ·∪S l (l, L) = e∪(e j −e)∪(S j (l)−e j ). We know that S j (l) ∈ E holds (since S j is a pseudo-sunflower), that e j ⊆ S j (l) holds (since e j is the pseudo-core of S j ), and that e ⊆ e j holds (since e is the core of a sunflower that has e j as one of its petals). This implies S(l) = S j (l) and the latter is an element of E.
3. Clearly, S(l, 0) = e and S(l, 1) = e j − e are disjoint and S(l, 1) has size at least 1 since e j is not a subset of e. The other S(l, i) are also disjoint from one another since the S j (l, i − 1) are disjoint among one another, and they are also disjoint from S(l, 0) and S(l, 1) (since all S j (l, i − 1) are disjoint from S j (l, 0) = e j ).
4. Finally, let z be the "divergence depth" of l and m, that is, the smallest number with l z = m z . For z = 1, we have S(l, 1)∩S(m, 1) = ∅ since S(l, 1) = e j −e and S(m, 1) = e j ′ −e for some indices j and j ′ and since the intersection of the two sunflower petals e j and e j ′ is exactly e. For z > 1, the leafs l and m lie in the same tree T k L rooted at some child c j of r and we have S(l, z) ∩ S(m, z) = S j (l, z − 1) ∩ S j (m, z − 1) and the latter intersection is empty since S j is a pseudo-sunflower. Proof. We must show that every hitting set X of H with |X| ≤ k is also a hitting set of H ′ L . That is, we must show that every k-pseudo-core C of level L contains at least one element of X. Let S be a T k L -pseudo-sunflower with pseudo-core C. The following definition will be crucial in the following: We say that X hits a node n of T k L if there is a leaf l of T k L such that n = l D (that is, n is the Dth node on the path l 0 , l 1 , . . . , l L from the root r = l 0 to l = l L ) and X ∩ (S(l, 0) ∪ S(l, 1) ∪ · · · ∪ S(l, D)) = ∅.
First, observe that X hits every leaf of T k L since, for them, D = L and S(l, 0) ∪ · · · ∪ . . . S(l, L) = S(l) is a hyperedge of H and, hence, gets hit by X.
Second, we claim that if X hits all children c 1 , . . . , c k+1 of a node n of T k L , then X also hits n. Let n be at depth D, so the children are at depth D + 1. By definition of "being hit by X," for each child c i of n there must be a leaf l i such that We claim that at least one of the l i also witnesses that X hits n. Otherwise, since all l i are in the subtree rooted at n, for all of them we would have From (1) and (2) we immediately get that X ∩ S(l i , D + 1) = ∅ must hold for all i ∈ {1, . . . , k + 1}.
Now, for any two different leafs l i and l j consider the two paths from the root to them. These paths will be identical exactly up to the node n and will then split into a path via the child c i and a path via the child c j . Now, in this situation the fourth property of pseudo-sunflowers tells us that S(l i , D + 1) ∩ S(l j , D + 1) = ∅ must hold. In other words, the k + 1 many sets S(l i , D + 1) in equation (3) are pairwise disjoint. However, this means that the size-k set X cannot contain one element of each of them. Thus, our assumption that X does not hit n has lead us to a contradiction. Third, we claim that X hits the root of T k L . This follows easily from the first two claims since X hits all leafs of T k L and whenever it hits all children of a node, it also hits the node. Clearly, this implies that X hits all nodes, including the root. Now, we are done since "X hits the root" means that X ∩ S(l, 0) = ∅ holds for at least one leaf l and S(l, 0) = C. Thus, X ∩ C = ∅, which was the claim.
Step 2: Pseudo-Cores Can Be Computed in Constant Depth. Theorem 5.1 states that the hypergraphs H ′ i form a matryoshka sequence and, thus, the Kernel Theorem tells us that the following hypergraph is a kernel for the hitting set problem: H) . Of course, the whole effort that went into the definition of the H ′ i and the proof of the matryoshka properties would be for nothing, if the H ′ i were not easier to compute than the H i .
This is exactly what we claim in the following theorem and prove in the rest of this paper: It is an analogue of Lemma 3.6 for pseudo-cores. The crucial difference in the formulation is that, now, we no longer get H ′ i−1 as input when we compute H ′ i , but rather we compute H ′ i "directly" from the original graph H. To compute the encoding of H ′ L , we can consider all candidate pseudo-cores in parallel. Thus, proving the theorem boils down to deciding for a subset C ⊆ V whether there exists a T k L -pseudo-sunflower S of H whose pseudo-core is C. Of course, we wish to use color coding for this and our definition of pseudo-cores and pseudo-sunflowers was carefully crafted so that it includes only requirements of the form "these parts of these hyperedges must be disjoint" (and not -as is necessary for describing cores of cores -statements like "these hyperedges must share the vertices that form petals"). Unfortunately, while we no longer need to ensure that certain parts of different hyperedges are identical, we must be careful that we do not inadvertently forbid vertices to be the same across hyperedges when we "do not care whether they are the same": Example 5.7. Suppose we wish to find two disjoint hyperedges e 1 = {v 1 , v 2 , v 3 } and e 2 = {v 4 , v 5 , v 6 } in a hypergraph H plus another hyperedge e 3 = {x, y} such that x / ∈ e 1 ∪ e 2 , but do not care whether y ∈ e 1 ∪ e 2 holds or not. We can easily enforce the disjointness properties by coloring v 1 to v 6 using colors 1 to 6 and x using color 7. However, how should we color y for which we do not care about disjointness (at least with respect to e 1 and e 2 )? Fixing any of the colors 1 to 3 for y or any of the colors 4 to 6 (or, for that matter, any other color) would be wrong, since this would enforce either y / ∈ e 2 or y / ∈ e 1 (or both).
Fortunately, there is a way out of the dilemma: we consider all feasible colors y could get in parallel. To formalize this "trick", we define a technical problem in which an undirected graph G is used to specify which vertices in hyperedges of a hypergraph H should be different. As is customary, a proper coloring of an undirected graph G = (U, F ) is a mapping c : U → C to some set C of colors with c(u) = c(v) for all {u, v} ∈ F . Let us write f [X] = {f (x) | x ∈ X} for the image of a set X under a function f . For an example instance see Figure 3. The idea behind this search is the following: The graph G imposes restrictions of the form "for the edge {u, v} the vertices c(u) and c(v) must be different." In principle, such restrictions are easy to enforce using color coding: use one color for c(u) and a different color for c(v). However, as explained in Example 5.7, we may run into a problem when there is no edge between two vertices x and y since, then, we may not rule out that c(x) = c(y) holds -which we would rule out when two different colors are used. The solution offered following the example is to try out all possible ways in which we may assign colors to vertices for which we "actually do not care" about their colors. These "possible ways" are modeled by the proper coloring c ′ from above.
In detail, recall the situation of Example 5.7 where we searched for two disjoint hyperedges e 1 = {v 1 , v 2 , v 3 } and e 2 = {v 4 , v 5 , v 6 } and a hyperedge e 3 = {x, y} with x / ∈ e 1 ∪ e 2 . This search can be modeled by a graph G whose vertex set U can be partitioned into U 1 = {u 1 , u 2 , u 3 }, The just-defined mapping c is a proper coloring of G since for every edge We are now ready to prove Theorem 5.6: Proof of Theorem 5.6. Recall that in order to prove the claim, we must solve the following problem in constant depth: Given H = (V, E), k, L, and a subset C ⊆ e ∈ E, check whether there exists a T k L -pseudo-sunflower S of H whose pseudo-core is exactly C. We must now show how the existence of the pseudo-sunflower can be checked using the technical problem p Grestricted-coloring.
The input for the restricted coloring problem will consist of a special graph G that encodes the different disjointedness properties of pseudo-sunflowers using edges and will consist of the hypergraph H ′ = V, { e − C | e ⊇ C, e ∈ E } . In other words, we restrict H to those edges that contain the alleged core C (other edges cannot be part of the sought pseudo-sunflower anyway) and we remove the core from the edge since they all contain it.
Let us now define the graph G = (U, F ). The objective of this definition is, of course, that there is a T k L -pseudo-sunflower S with core C if, and only if, there a proper coloring c : Pseudo-sunflowers are mappings from leafs(T L k ) × {0, . . . , L} to subsets of V such that for each leaf l the union S(l, 0) ∪ · · · ∪ S(l, L) is a hyperedge in E. In our case, we must have S(l, 1) ∪ · · · ∪ S(l, L) ∈ E(H ′ ) since S(l, 0) = C and we removed the fixed core C already from the hyperedges of H ′ . In G, we will have one set U l for each leaf l of T k L : The vertices that will be assigned to the elements of U l by the coloring c should then form exactly the hyperedge S(l, 1) ∪ · · · ∪ S(l, L).
If we knew that each S(l, i) had size exactly 1, we could set U = leafs(T . It remains to explain how we put edges into G such that the colorings of G induce pseudo-sunflowers. The following edges are present in G to ensure the four properties from Definition 4.1: 1. Nothing needs to be done to ensure the first property (S(l, 0) = C) since H ′ only contains hyperedges that used to contain C.
2. Nothing needs to be done to ensure the second property (S(l) ∈ E) since c[U l ] ∈ E(H ′ ) will ensure that S(l) − C ∈ E(H ′ ) holds and, thus, S(l) ∈ E(H).
3. To ensure the third property (S(l, i) ∩ S(l, j) = ∅ for i = j), for each l ∈ leafs(T k L ) and every i = j and all x, y ∈ {1, . . . , d} let {(l, i, x), (l, j, y)} be an element of F , that is, let it be an edge of G.

4.
To ensure the fourth property (S(l, z) ∩ S(m, z) = ∅ must hold when l z and m z have the same parent), for each l, m ∈ leafs(T k L ) and the smallest number z with l z = m z and all x, y ∈ {1, . . . , d} let {(l, z, x), (m, z, y)} be an element of F .
With this definition, we claim that C is a k-pseudo-core of level L of H if, and only if, (H ′ , G) is a element of p G -restricted-coloring. If we can show this, we are done by Lemma 5.9.
We need to prove two directions. First, let a T K L -pseudo-sunflower S of H with core C be given. We must argue that there is a proper coloring c : U → V of G with c[U l ] ∈ E(H ′ ) for all leafs of T k L . This coloring is the following: Consider all leafs l and all numbers i ∈ {1, . . . , L}. For each pair, the set S(l, i) consist of some vertices v 1 , . . . , v p ∈ V for some p = |S(l, i)| ∈ {1, . . . , d}. We set c(l, i, x) = v x for x ∈ {1, . . . , p} and c(l, i, x) = v p (or any other element of S(l, i), it does not matter) for x ∈ {p + 1, . . . , d}.
With this definition, we clearly have c[U l ] = S(l, 1)∪· · ·∪S(l, L) and since S(l) ∈ E, the latter is an element of E(H ′ ). Furthermore, c is a proper coloring: For all edges {(l, i, x), (l, j, y)} ∈ F we know that the colors c(l, i, x) and c(l, j, y) are different since c(l, i, x) ∈ S(l, i) and c(l, j, y) ∈ S(l, j) and S(l, i) ∩ S(l, j) = ∅. Next, for the edges of the form {(l, z, x), (m, z, y)} ∈ F we also have that c(l, z, x) and c(m, z, y) are different since S(l, z) and S(m, z) are disjoint.
To see that S has the properties of a pseudo-sunflower, consider the four properties. The first property is clearly true by definition. The second follows from c[U i ] ∈ E(H ′ ) and, hence C ∪c[U i ] ∈ E(H). The third item follows from the following fact: For any two vertices v x ∈ S(l, i) and v y ∈ S(l, j) for i = j, there is an edge between (l, i, x) and (l, j, y) in G and, thus, v x = v y . This shows that S(l, i) ∩ S(l, j) = ∅ must hold; and note that, clearly, S(l, i) = ∅ always holds. For the fourth item, we have S(l, z) ∩ S(m, z) = ∅ since for all v x ∈ S(l, z) and v y ∈ S(m, z) there is an edge between (l, z, x) and (m, z, y) in G.
Theorem 5.6 now implies Theorem 1.2 by simple standard arguments: Proof of Theorem 1.2. The only difference between the above claim and the claim of Theorem 5.6 (apart from the exact formulation) is that Theorem 1.2 requires the AC 0 -circuit family to have size |V | c |E| c for some constant c, while Theorem 5.6 allows it to have size f (k, d)|V | c |E| c . To reduce the size, on input (H, k), a kernelization algorithm for Theorem 1.2 first checks whether we have f (k, d) > |V | c |E| c and, if so, just outputs (H, k); otherwise it runs the kernelization algorithm from Theorem 5.6, which needs size f (k, d)|V | c |E| c ≤ |V | 2c |E| 2c .

Conclusion
The results of this paper can be summarized as p k,d -hitting-set ∈ para-AC 0 or, equivalently, that kernels for the hitting set problem parameterized by k and d can be computed by a single AC 0 -circuit family. This result refutes a conjecture of Chen et al. [11]. The proof introduced a new technique: Iterated applications of color coding can sometimes be "collapsed" into a single application. This collapsing is not always straightforward (as the present paper showed) and additional technical machinery may be needed to make it work.
The proof of our main result would be much simpler if the number of k-cores of a hypergraph depended only on the parameters k and d (since, then, only one round would be needed in the parallel algorithm). While we gave examples that refute this hope, it may be possible to tweak the idea a bit: We can compute in constant parallel time the set of all inclusion-minimal k-cores of a hypergraph. We believe that we can prove that the number of these inclusionminimal k-cores depends only on k and d (unfortunately, we need rather involved and technical combinatorics and the dependence on k and d seems to be "quite bad"). Nevertheless, if this is the case, we get a different proof that p k,d -hitting-set has an AC 0 -kernelization, where the complexity of proving correctness is shifted away from the algorithm (which gets much simpler) towards the underlying graph theory and combinatorics.