Abstract 1 Introduction 2 Preliminaries 3 Proposed Methods 4 Integrality Gaps 5 Conclusion References

Targeted Least Cardinality Candidate Key for Relational Databases

Vasileios Nakos ORCID National and Kapodistrian University of Athens, Greece
Archimedes Athena RC, Marousi, Greece
Hung Q. Ngo ORCID Relational AI, Berkeley, CA, USA Charalampos E. Tsourakakis ORCID Relational AI, Berkeley, CA, USA
Abstract

Functional dependencies (FDs) are a central theme in databases, playing a major role in the design of database schemas and the optimization of queries [37]. In this work, we introduce the targeted least cardinality candidate key problem (TCAND). This problem is defined over a set of functional dependencies and a target variable set TV, and it aims to find the smallest set XV such that the FD XT can be derived from . The TCAND problem generalizes the well-known NP-hard problem of finding the least cardinality candidate key [32], which has been previously demonstrated to be at least as difficult as the set cover problem.

We present an integer programming (IP) formulation for the TCAND problem, analogous to a layered set cover problem. We analyze its linear programming (LP) relaxation from two perspectives: we propose two approximation algorithms and investigate the integrality gap. Our findings indicate that the approximation upper bounds for our algorithms are not significantly improvable through LP rounding, a notable distinction from the standard Set Cover problem. Additionally, we discover that a generalization of the TCAND problem is equivalent to a variant of the Set Cover problem, named Red Blue Set Cover [8], which cannot be approximated within a sub-polynomial factor in polynomial time under plausible conjectures [11]. Despite the extensive history surrounding the issue of identifying the least cardinality candidate key, our research contributes new theoretical insights, novel algorithms, and demonstrates that the general TCAND problem poses complexities beyond those encountered in the Set Cover problem.

Keywords and phrases:
functional dependencies, candidate key, approximation algorithms, hardness
Copyright and License:
[Uncaptioned image] © Vasileios Nakos, Hung Q. Ngo, and Charalampos E. Tsourakakis; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Information systems Database design and models
Editors:
Sudeepa Roy and Ahmet Kara

1 Introduction

Relational databases are a fundamental component of modern information systems, used to store and manage vast amounts of data across a wide range of industries and applications [37]. However, designing an effective database schema can be a complex task, requiring careful consideration of factors such as data integrity, performance, and scalability. One key tool in this process is the use of functional dependencies (FDs), which provide a way to describe the relationships between attributes in a database relation [16]. A functional dependency (FD) is a statement that indicates that the value of one or more attributes uniquely determines the value of another attribute. For example, consider a relation with attributes Student ID, Student Name, and Student Email. In this relation, each student id is associated with a unique student name and email. This means that if we know a student’s ID, we can determine their name and email. This relationship can be represented by the following FD: Student ID Student Name, Student Email. Alternatively, we express that the Student ID variable functionally determines the name and email, meaning that each id uniquely corresponds to one student name and email in the relation. A key is a set of one or more attributes that uniquely identifies a tuple (or record) within a relation. A key ensures that there are no duplicate records in the table and establishes a way to reference records for relational operations. A candidate key is any key that can serve as the primary key, i.e., a set of attributes that uniquely identifies a tuple within a relation. Finding a candidate key in a schema requires finding a set of attributes that functionally determine all the rest [17]. It is important to note that it is often customary to select a candidate key with the least number of attributes as the primary key. This approach simplifies the database design and can enhance storage efficiency and query speed, particularly when the primary key plays a role in indexing, joins, and various database tasks [37]. For example, in query optimization, fewer attributes in a key mean fewer columns to index and process during queries, which enhances the speed and efficiency of database operations. Furthermore, using the smallest possible key simplifies the design of the database schema, making it easier to understand and maintain. It also reduces the likelihood of errors in data management and makes integrity checks more efficient. This problem is known as the minimum candidate key problem [30, 32]. Furthermore, finding the Boyce–Codd normal form (BCNF) to eliminate redundancy is based on functional dependencies [37]. Understanding functional dependencies is essential for database designers and administrators to create efficient and effective database schemas that accurately store and manage data. Functional dependency analysis is a major topic with a variety of applications beyond schema design query optimization, that additionally include cost estimation, order optimization, selectivity estimation, estimation of (intermediate) result sizes and data cleaning among others [5, 6, 12, 35, 23]. The DISTINCT clause appears frequently in SQL queries and frequently requires an expensive sort to remove duplicates. Functional dependency analysis can identify redundant DISTINCT clauses [34], thus lowering significantly the execution cost of a query.

In this work we revisit functional dependency analysis and make several key contributions to this longstanding line of work.

  • Novel formulation: We introduce a well-motivated, novel formulation that generalizes the classic problem of finding the least cardinality key of a schema [30, 32]. We refer to this problem as the targeted least cardinality candidate key generation problem, or TCAND for short.

    Problem 1 (Targeted Least Cardinality Candidate Key (TCAND)).

    Given a set of functional dependencies and a set of target variables TV, the aim is to determine a set of variables XV with the smallest cardinality, such that the closure X+ satisfies the condition TX+. In other terms, the functional dependency XT is logically implied from the set .

  • Hardness: We study in depth the hardness of approximation of the TCAND formulation. Despite the long history and importance of the problem in its general form when T=V [32], surprisingly not much is known on the approximability of the problem. As we show the known approximation lower bound [1] is tight only for some special cases, while the general case is significantly harder. We achieve this result by establishing a novel connection with the Red Blue Set Cover that allows us to leverage recent progress to establish the a powerful hardness result assuming the Dense-vs-Random conjecture [9].

  • Exact IP formulation: We present an exact integer programming (IP) formulation that represents the TCAND problem as a layered set cover problem. Intuitively, each layer corresponding to a round of 𝐹𝐷 inference. With recent advancements in integer programming solver software, our formulation can be practical for real-world use for instances of moderate size. From a theory perspective, it serves as the basis for designing approximation algorithms.

  • Approximation algorithms: We design two approximation algorithms based on the linear programming relaxation of our integer programming (IP) formulation. Both algorithms rely on solving a variant of the TCAND problem we introduce, parameterized by the number of rounds of inference D.

    Problem 2 (D-round-TCAND).

    Given a set of functional dependencies , and a set of target variables TV we want to find a least cardinality set of variables XV whose closure X+ includes T, i.e., X+T, by performing at most D rounds of FD inference.

    Our approach is based on approximating Problem 2 for D=1; this gives a natural approximation algorithm for the D-round TCAND problem with an exponential dependence on D. It is worth noting that Problem 1 is a special case of Problem 2 by setting D=n as we explain later in detail. We also show that our approximation guarantee is asymptotically tight by studying the integrality gap of the LP relaxation.

  • Equivalence with the Red Blue Set Cover problem: We discover an equivalence between the TCAND problem and the Red Blue Set Cover problem [8], a variant of the Set Cover problem. This discovery holds dual significance for the TCAND problem. Firstly, it introduces an additional approximation algorithm developed by Chlamtáč et al. [11] for the Red Blue Set Cover problem, and secondly, it establishes an inapproximability result.

2 Preliminaries

Functional dependencies.

A relational database schema R, represented as R(A1,,An), consists of a set of attributes or variables. An instance of R, denoted by r(R), is a set of tuples, where each tuple is an element of the Cartesian product of the attributes’ domains, i.e., r(R)dom(A1)××dom(An). We also use V={A1,,An}, or simply V=[n], to denote the set of attributes/variables. Each element tr(R) is referred to as a tuple. Functional dependencies (FDs for short) are properties of the semantics of the attributes in R [17]. Specifically an FD is a constraint between two sets of attributes X,YV. We say that X functionally determines Y and this means that if two tuples have the same value for all the attributes in X, they must also have the same values for all the attributes in Y. This is denoted as XY. We refer to an FD XY as regular when |Y|=1. Any irregular FD Xy1y2yk is equivalent to the set of regular FDs Xyi for i=1,,k. An input set of FDs, may logically imply more FDs. For instance, the set ={ab,bc} logically implies ac. The set of all possible valid FDs for is its closure +. The inference of valid FDs is performed using Armstrong’s axioms which are sound and complete [16]. In practice |||+|. Finding a smaller set of FDs than such that +=+ is known as the canonical cover problem and can be solved efficiently [37]. Other compression schemes are also available, see [3]. The attribute closure X+ is the set of attributes that are functionally determined by X. In contrast to the FD closure, computing the closure X+ of a subset of attributes XV is solvable in linear time [37].

A key of a relation r is a subset XV that satisfies two conditions: (i) uniqueness, meaning no two distinct tuples in r have identical values for the attributes in X, and (ii) minimality, meaning no proper subset of X satisfies the uniqueness property. When X is a key, the functional dependency (FD) XV is valid, or equivalently, the closure of X, denoted X+, is equal to V. A subset of attributes X is considered a super-key if it satisfies the uniqueness property but not the minimality property. If a relation has more than one minimal key, each of these keys is referred to as a candidate key of R. Finding the least cardinality key is NP-hard. Specifically, deciding if there exists a key of cardinality k is NP-complete using a straight-forward reduction from vertex cover [32]. Furthermore, in terms of approximation algorithm very little is known. Specifically, Akutsu and Bao [1] proved that the problem is at least as hard as the set cover problem [18] but they do not discuss algorithmic upper bounds.

Set Cover and Red Blue Set Cover.

The Set Cover problem is a quintessential problem in computer science, renowned for its wide applicability and fundamental role in computational complexity theory. It was one of Karp’s 21 NP-complete problems [24], serving as a cornerstone for the study of approximation algorithms and computational intractability. The problem is defined as follows: given a universe U={u1,u2,,un} and a collection of subsets S={S1,S2,,Sm} where each SiU, the Set Cover problem seeks to find a minimum subset C[m] of set indices such that iCSi=U. Feige showed that the Set Cover problem cannot be approximated in polynomial time to within a factor of (1o(1))lnn unless NP has quasi-polynomial time algorithms. This inapproximability result was further improved by Dinur and Steuer who showed optimal inapproximability by proving that it cannot be approximated to (1o(1))lnn unless P=NP [14]. We use the latter result in Theorem 6. The Set Cover problem admits an approximation within a factor of O(logn) utilizing either a straightforward greedy strategy or a randomized algorithm based on linear programming (LP) rounding techniques. Additionally, there is a deterministic LP-based algorithm that guarantees an f-factor approximation, with f denoting the maximum frequency an element of the universe is represented in the set collection S [42]. The Set Cover problem is not only fundamental in computer science but also has a wide range of applications, as discussed in [13].

As we show, a variant of the Set Cover problem that plays an important role for the TCAND problem is the Red Blue Set Cover problem introduced by Carr et al. [8]: given a universe U=RB where R and B are disjoint sets representing red and blue elements respectively, and a collection of subsets S={S1,S2,,Sm} where each SiU, the Red Blue Set Cover problem seeks to find a subset CS such that SiCSiB=B and SiCSiR is minimized. Recently, Chlamtáč et al. [11] proved the following state-of-the-art approximation result for the Red Blue Set Cover problem.

Theorem 1 (Chlamtáč et al. [11]).

There exists an O(m1/3log4/3nlogk)-approximation algorithm for the Red Blue Set Cover problem where m is the number of sets, n is the number of red elements, and k is the number of blue elements.

To discuss the inapproximability of the Red Blue Set Cover we need to introduce the Dense-vs-Random Conjecture [7]. Given a graph G(V,E), the density of a subgraph induced by SV is defined as ρ(S)=e(S)|S|, which is the ratio of the number of edges to the number of nodes in the subgraph [20]. The densest k-subgraph problem (DkS) problem asks for the densest subgraph with exactly k nodes; it is NP-hard with the best-known approximation ratio being Ω(1/n1/4+ϵ) for any ϵ>0 [7]. This approximability result is far off from the best-known hardness result that assumes the Exponential Time Hypothesis (ETH). If ETH holds, then DkS cannot be approximated within a ratio of n1/(loglogn)c for some c>0 [33]. Define the log-density of a graph with n nodes as logn(Davg), where Davg represents the average degree. The Dense-vs-Random Conjecture on graphs [9] conjectures that it is hard to distinguish between the following two cases: 1) G=G(n,p) where p=nα1 (and thus the graph has log-density concentrated around α), and 2) G is adversarially chosen so that the densest k-subgraph has log-density β where kβpk (and thus the average degree inside this subgraph is approximately kβ). In this context, G(n,p) represents the random Erdős and Rényi graph model  [15, 19].

Conjecture 2 ([7, 10, 9]).

For all 0<α<1, for all sufficiently small ε>0, and for all kn, we cannot solve Dense vs Random with log-density α and planted log-density β in polynomial time (w.h.p.) when β<αε.

Using an extension of the above conjecture on hypergraphs, Chlamtáč et al. [11] proved the following inapproximability result.

Theorem 3 (Chlamtáč et al. [11]).

Assuming the Hypergraph Dense-vs-Random Conjecture, for every ε>0, no polynomial-time algorithm achieves better than O(m1/4εlog2k) approximation for the Red Blue Set Cover problem where m is the number of sets and k is the number of blue elements.

Integrality Gap.

The integrality gap of an integer program is the worst-case ratio over all instances of the problem of value of an optimal solution to the integer programming formulation to value of an optimal solution to its linear programming relaxation [42, 41]. Notice that in the case of a minimization problem, the integrality gap satisfies

maxinstances QOPTIPOPTLP1.

This gap provides insights into how closely the LP relaxation approximates the IP and is a measure of the performance of approximation algorithms. A small integrality gap (i.e., close to 1) indicates that the LP relaxation is a good approximation of the IP, while a large gap suggests the LP relaxation might not yield a good approximation and that other approximation strategies may be needed. It is often used as a benchmark to understand the effectiveness of approximation algorithms and to determine the best possible approximation ratio that can be achieved by any polynomial-time algorithm for NP-hard problems. Lovász proved that the integrality gap for the straight-forward LP formulation of the Set Cover is O(logn) [31].

Equitable coloring.

In Section 3, we make use of the following theorem, known as the equitable coloring theorem, which was proved by Hajnal and Szemerédi [22].

Lemma 4 (Hajnal-Szemerédi [22]).

Every graph with n vertices and maximum vertex degree at most k is k+1 colorable with all color classes of size nk+1 or nk+1.

There exist efficient algorithms for finding such a coloring, e.g.,  [27, 28]. The best known algorithm is due to Kierstead et al. [28] and runs in O(kn2) time and returns such an equitable coloring. We apply the Hajnal-Szemerédi theorem to establish a Chernoff-type concentration result under conditions of limited dependencies, as demonstrated in works like [29, 36].

3 Proposed Methods

3.1 Integer Programming Formulation

Figure 1: Visual representation of IP (1).

We formulate the TCAND problem as an integer program (IP) that provides an optimal solution. This formulation serves as the basis of our LP-based approximation algorithms. Notationally, we define [k,n]=def{k,k+1,,n} and [n]=[1,n]. We assume, without loss of generality, that each FD’s right-hand side has a size exactly equal to 1. Figure 1 visualizes the variables introduced by our IP. Specifically, we introduce a set n2+n variables xid for d[0,n],i[n]. The bottom level corresponds to the set of Boolean variables xin. We constraint the set of variables in this layer corresponding to the target variables (blue dotted circles) to be equal to 1. In general, the set of variables {xinD} will indicate what variables we should include in our output if we allow for D rounds of inference, for D[n]. For any layer k=n,,1, a variable xik will be set to 1 if and only if either xik1=1 or if there exists an FD of the form i1,,iri where all the variables on the left side in the previous layer k1 are equal to 1, i.e., xi1k1==xirk1=1. In this case, we shall say that the FD is activated. We can express this logic as

xik=OR(xik1,AND(xi1k1,,xirk1),),

where we have a AND term for each FD of the form i1iri as linear constraints. The logical operators OR, AND can be easily expressed as linear constraints [43]. Towards this formulation, we introduce a new set of variables zLS(d) which corresponds to whether FDs with left hand side LS can be activated in round d, i.e., all the variables participating in LS from the previous layer are already set to 1. Putting those constraints together along with the objective function, we arrive at the following IP for D-round TCAND where 1Dn.

minimizej=1nxjnDsubject toxidxid1+LS:LSizLSd d[nD+1,n],i[n]zLSdxjd1 LSi,jLS,d[nD+1,n]xin=1 iT[n] (1)

By setting D=n, the IP is guaranteed to return an optimal solution. This is because applying the FD rules a maximum of n times is sufficient; if an iteration fails to fix any additional variables, subsequent iterations will not alter the outcome and a variable, once set, does not change.

3.2 Simple FDs

Before addressing the general case of the problem, we focus on an important special case in this section. Notice that without any loss of generality, the right side of any 𝐹𝐷 consists of a single attribute. We denote the set of all left-sides of FDs as 𝒮={LSV:(LSi),iV}. If an FD has a single variable on the left side, we refer to this FD as simple. Otherwise, we refer to it as non-simple. We call a set of FDs simple if all FDs in are simple. If there exists at least one non-simple FD in , we refer to as regular or non-simple. For example, the set of FDs {ab,bc,cd} is simple because all FDs are simple. The set of FDs {ab,bcd} is regular/non-simple since the FD bcd is non-simple. We also define the following natural graph for any set of FDs. It is worth mentioning that similar notions exist in the literature, see [4] and [38, Definition 3].

Definition 5.

Let be a set of FDs. We define the corresponding FD-graph G (or simply G) as follows: for each variable i appearing in we create a vertex vi. There exists a directed edge (vi,vj) when there exists an FD of the form Xy with iX,y=j.

Designing approximation algorithms is easier for simple FDs. Intuitively, when dealing with a simple set of FDs, the FD-graph precisely mirrors the input data. For example, if the FDs are simple and the FD-graph is strongly connected, any single variable i is an optimal solution for any target set T, as the closure of i is the set of all variables, i.e., {i}+=V. However, in general the FD-graph may not be strongly connected. However, it is a well-known fact that any directed graph can be decomposed as a directed acyclic graph (DAG) of strongly connected components (SCCs) [40] and this decomposition requires linear time in the size of the graph. We use this fact to prove a refined approximation result and establish that that the lower bound established by Akutsu and Bao [1] is tight, see also [18]. We present this result in the subsequent theorem.

Theorem 6.

Let be a set of simple FDs and let g be the number of the strongly connected components (SCCs) of G. Then there exists a polynomial time lng-approximation algorithm for the TCAND problem. Furthermore, it cannot be approximated within (1o(1))lng unless P=NP.

Proof.

We define for each node vi in the FD-graph G, the set Reach(vi) of nodes that are reachable from vi. Then, Si:=Reach(vi)T is the set of target variables reachable from vi. Notice that for any vi,vj that belong to the same SCC the sets Si,Sj are the same, i.e., Si=Sj. Thus, we define S^i,i=1,,g to be the set of target variables reachable from each SCC. It is straight-forward to observe that solving the Set Cover problem for the instance defined by {S^1T,,S^gT} and universe T yields the optimal solution. This allows us to use the well known lnglnlng+Θ(1)-approximation greedy algorithm for the Set Cover  [39]. By Dinur and Steuer, the TCAND for simple FDs cannot be approximated to (1o(1))lng unless P=NP. Notice that the number of SCCs g can be significantly less than n. Furthermore, our proof directly yields that the above bound can be further tightened to the logarithm of the number of sources in the DAG of the FD-graph, which is trivially upper bounded by the number of SCCs. This is the case for it suffices to pick at most one node from each strongly connected component of G that is a source; this can be any node. We state this as the following corollary.

Corollary 7.

Let be a set of simple FDs and let s be the number of the source nodes in the SCC DAG of the fd-graph G. Then there exists a polynomial time lns-approximation algorithm for the TCAND problem. Furthermore, it cannot be approximated within (1o(1))lns unless P=NP.

3.3 LP Relaxation and Approximation Algorithms

Our building block for the D-round TCAND problem is solving the 1-round TCAND problem and then iterating this algorithm for D layers. Given its importance and for the reader’s convenience, we introduce it as a special case with simplified notation compared to the IP (1).

Single layer/1-round TCAND.

Our goal in the single-layer problem is to choose a set of variables S[n] such that their one step closure includes the target variables. By the term one step closure, we mean that an attribute i is active if it is either included in S or if there exist attributes i1,,ir such that they are all active (i.e., in S) and there exists an FD in of the form i1i2iri. The bottom row with the squares encodes the target attributes; for each attribute we have a Boolean variable xi and this is set to 1 for each target variable (blue filled squares); the rest may be 0 or 1 depending on which set of variables we will activate on the top row. To encode the output set S we define Boolean variables yi for i=1,,n. Our goal is to minimize the number of variables we include in S or in terms of the y variables the sum i=1nyi. The constraint of covering the target variables is expressed as xi=1 for each target variable iT. The connection between the y and x variables –as explained also earleir– is expressed as follows xi=OR(yi,AND(yi1,,yir),) where we include in the OR all FDs of the form i1iri as the AND of the corresponding left-side variables i1,,ir. Figure 2 illustrates a single-layer version of the TCAND problem. Each column corresponds to an attribute i, i=1,,n.

Figure 2: The Boolean variables x1,,xn denote whether an attribute i is active, i.e., meaning it is included in the closure of the selected set of variables. The target variables are all set to 1.
LP Relaxation.

We explicitly express the linear programming relaxation of the integer program (1), incorporating a single layer or round of FD inference. In Sections 3.3.1 and 3.3.2 we present a deterministic and randomized based on the following LP relaxation and we show how we apply it for the D-round TCAND problem. For simplicity, we assume, without any loss of generality, that the set of FDs includes the valid FDs ii for each i[n].

minimizej=1nyjsubject toyi+LSizLS1,iTzLSyj,jLS where LSi,iTyj,zLS[0,1],jV,LS of the form LSi,iT (2)

3.3.1 Deterministic rounding

Our deterministic rounding approximation algorithm for the single-round TCAND problem solves the LP relaxation (2) and outputs all attributes i for which the corresponding variable yi is at least a certain threshold. The threshold value is determined by the input. Define fi as the number of input FDs of the form Xi, represented by fi=|XV:Xi|. Let f denote the maximum value of fi across all elements in V, i.e., f=maxiVfi. In simple terms, f represents the maximum number of variables on the left side of any FD in our collection of FDs, . The threshold value is set equal to 1f+1. This simple process is outlined for completeness as Algorithm 1 and the approximation guarantee states as Theorem 8.

Algorithm 1 (f+1) approximation algorithm for the 1-round TCAND (Problem 2 with D=1).
 Solve the LP relaxation (2)
I{i:yi1f+1}
 Output I
Theorem 8.

Algorithm 1 is an (f+1) approximation for the 1-round TCAND problem.

Proof.
Feasibility.

First we prove that TI+. We note that for all iT the inequality

yi+LSizLS1

implies that at least one of the f+1 summands will be at least 1f+1. If that summand is yi, then we add i to S, and thus i is trivially in the closure of S+. Otherwise, zLS1f+1 for some LS and due to the linear constraints yj1f+1,jLS. This means that all such j will be added to I and therefore i will be in the closure I+.

Approximation guarantees.

The cost of the solution is upper bounded as follows:

|I|(f+1)iIyi=(f+1)OPTLP(f+1)OPTIP.

This completes our proof. We now state our main result for the D-round TCAND problem as Theorem 9. Our proof is constructive. To solve the D-round TCAND problem, we iteratively apply Algorithm 1 D times, allowing for D rounds of FD inference. Our algorithm is described as Algorithm 2. We return to the indexing notation previously used in Figure 1. Observe that in this case the objective becomes the minimization of j=1nxjnD where Dn. Next, we present Theorem 9, which demonstrates how the approximation algorithm we developed for the 1-round TCAND can be applied to the D-round TCAND.

Algorithm 2 (f+1)D approximation algorithm for the D-round TCAND (Problem 2).
 Solve the LP relaxation (1) to obtain fractional values for all variables x,z
I{i:xinD1(f+1)D}
 Output I
Theorem 9 (Approximating TCAND).

There exists a polynomial time (f+1)D-approximation algorithm for the D-round TCAND problem.

Proof.

Similar to the proof of Theorem 8, we first establish feasibility, ensuring that the closure of the output set I contains all target variables T, and then we prove the approximation guarantee.

Feasibility.

For each target variable iT, xin=1. By the LP inequality,

1=xinxin1+LS:LSizLS(n1) (3)

with the same reasoning as in Theorem 8, either xin11f+1 or zLSn11f+1 for some LSi. The latter inequality yields that

xjn11f+1,jLS.

Thus, either of the sets {xin1},{xjn1}jLS for some FD LSi must have all its elements larger than 1f+1. We apply the same reasoning for the previous layer n2, with the difference that the left-hand-side of Inequality 3 is 1f+1. This implies that for a variable xjn1 that is at least 1f+1 either xjn21(f+1)×1(f+1)=1(f+1)2 or xjn21(f+1)2 for all jLS for some LSj with zLS1(f+1)2. Using backwards induction and the same averaging argument, we obtain that I is a feasible solution.

Approximation guarantees.

We simply observe that the output size |I| satisfies

|I|(f+1)DiIxi(f+1)DOPTLP(f+1)DOPTIP,

which yields the desired bound.

3.3.2 Randomized rounding

Our randomized algorithm relies again on solving the LP relaxation (2) to obtain {yi}i[n] values and on the KKMS algorithm [28] as a subroutine for finding an equitable Hajnal-Szemerédi partition as described in Lemma 4. The algorithm is outlined in pseudocode as Algorithm 3. Let 𝒮 be the set of all left-side sets of variables that appear in , i.e., 𝒮={LS:LSi}. Define Δ=maxLS𝒮|{LS𝒮:LSLS}| denote the maximum number of FDs that share at least one common attribute with any FD in . The algorithm initiates a set OUT that will contain a set of variables whose closure will contain the target set T with high probability. The algorithm considers each target element separately. To determine which variables we will include in the set OUT we use the constructive polynomial time algorithm for Hajnal-Szemerédi [22] lemma 4. This allows us to find partition the FDs into sets whose left sides share no attribute. This ensures that the joint distribution of those FDs factor over the individual left sides due to independence; we elaborate more on this in the following paragraph. Among those sets we choose one set with the property that the sum of zLS values is at least 1Δ+1; such a set is guaranteed to exist by a simple averaging argument.

Specifically, let us consider the solution to the 1-round TCAND LP relaxation, yielding fractional values y1,,yn. Focusing on a specific target element tT, we define t={LS𝒮:LSt} as the set of FDs with variable t on their right-hand side. Viewing the left sides of these FDs as a collection of hyperedges, our objective is to randomly select attributes such that at least one hyperedge “survives” after sampling, namely all the variables are included in OUT. This ensures that t is included in the closure of the randomized output. As mentioned earlier, analyzing this randomized procedure involves dependencies; the joint distribution of the survival of two hyperedges does not factor over the variables in them, since they may overlap. e.g., Xt and Yt, share attributes, i.e., XY. This interdependence adds complexity to the analysis of a randomized rounding approach akin to the Set Cover algorithm [42, Section 1.7] and we address it using Lemma 4. We state our main result as the next theorem.

Algorithm 3 2logn(Δ+1)-approximation algorithm for the 1-round-TCAND (Problem 2 with D=1).
 Solve the LP relaxation (2) to obtain {yi}i[n] values
 Compute Δ=maxLS𝒮|{LS𝒮:LSLS}|
OUT
for  each target element tT do
  Find a set Sj of FDs {LSt} with the properties that (i) no two FDs share an attribute and (ii) whose sum of zLS1Δ+1 using the KKMS algorithm [28].
  For each variable kSj, toss 2(Δ+1)logn coins each with success probability yk.
  if  success at least once for variable k  then
   OUTOUT{k}
  end if
end for
 Return OUT
Theorem 10.

Then, there exists a polynomial-time c(Δ+1)logn-approximation algorithm that solves the 1-round TCAND problem with high probability, where c is a constant.

Proof.

Define i to be the bad event that target element i is not covered by Algorithm 3. Fix any target element i and consider a meta-graph G where each node represents the left-side of some FD LSi and two nodes LSj,LSk are connected iff LSjLSk. Recall, Δ=maxLS|{LS:LSLS}| and thus the maximum degree in G is upper-bounded by Δ. We invoke the equitable coloring theorem 4 on G to obtain color classes S1,,SΔ+1 of size (essentially) nΔ+1. By grouping the terms zLS according to color classes we obtain j=1Δ+1LSSjzLS1. For at least one of the color classes j the summation term LSSjzLS1Δ+1. Let j be such an index. Observe that all the FDs within the Sj share no attributes since by the equitable coloring theorem they form an independent set in the meta-graph G. Thus, we obtain from the independence of the coin tossing

𝐏𝐫[i not activated] =LSSj(1kLSyk)LSSjekLSyk=
=exp(LSSjkLSyk)e1Δ+1.

For each attribute j we toss a biased coin with probability yj of success c(Δ+1)logn times independently where c>1 is a constant. If success occurs at least once, we include j in our output. The probability pj that an element j is included in the output satisfies pj=1(1yj)c(Δ+1)lognc(Δ+1)lognyj. It is straight-forward to show that using this procedure

𝐏𝐫[i]eclogn(Δ+1)Δ+1=1nc.

Furthermore, the expected cost of Algorithm’s 3 is upper bounded as follows:

𝔼[OUTPUT COST] i=1npii=1n(c(Δ+1)logn)yi=c(Δ+1)lognOPTLP
(c(Δ+1)logn)OPTIP.

Since 𝐏𝐫[iT not activated ]=𝐏𝐫[ii], by a union bound we conclude that all target variables are activated with high probability for any constant c>1:

𝐏𝐫[ii] |T|maxiT𝐏𝐫[i not activated]n1nc=o(1).

Using the rule of conditional probability and the fact that the good event i¯ (i.e., all target variables are covered) holds whp, we obtain the desired result

𝔼[OUTPUT COST|¯]O((Δ+1)logn)OPTIP.

We apply our randomized procedure for D layers in the same manner as the deterministic algorithm, achieving an approximation guarantee of (c(Δ+1)logn)D. The only distinction from the deterministic approximation algorithm is ensuring a success probability of 1o(1). This requirement is easily met, as the failure probability for a single application of the FD rules is 1nc for some sufficiently large constant c. By applying a union bound over D rounds, since Dn, we achieve the desired result.

Remarks.

Solving the TCAND problem using an integer program (IP) can be a practical approach for small to medium-scale instances. In a query optimizer, where speed is crucial, this method can be effectively applied to smaller instances. Between the two approximation algorithms we presented, the deterministic algorithm is more straight-forward to implement, as the randomized algorithm relies on the complex algorithm due to Kierstad et al.[28] for finding an equitable coloring on a meta-graph of the left-sides of FDs. From an approximation guarantee perspective, the two approximation algorithms cannot be directly compared based due to different parameterizations. While the parameters clearly cannot take arbitrary values (e.g., the number of FDs || is upper bounded by nf given that each variable i[n] participates in at most f FDs and Δ||1), the values f+1,(Δ+1)logn can be either larger or smaller depending on the specific instance.We present two extreme scenarios to illustrate this claim, though such situations are unlikely to occur in practice. For example, when f=Θ(||)=O(n) (e.g., a constant number of variables are on the RS of f=O(n) FDs per each), and Δ=O(1) (e.g. the left-sides are singleton sets), the value (Δ+1)logn is less than f+1 asymptotically. On other other extreme, there exist instances where Δ=Θ(|F|) (e.g., there exists one common variable to all the left-sides of FDs) and f is a low value making the value f+1 smaller than (Δ+1)logn. In relatively large practical instances, these extreme scenarios do not occur. However, the parameters generally lean towards the deterministic algorithm side, as Δ tends to be large due to the presence of a few common variables on the left side of most of the FDs, while f||. For these reasons, we find the deterministic algorithm to be more practical. However, since it requires solving an LP, there is still an open area for developing well-performing heuristics for systems.

3.3.3 𝟏-round TCAND is equivalent toRed Blue Set Cover

We discover that the general case (regular FDs) for 1-round TCAND problem the problem is equivalent to a variant of the Set Cover problem, referred to as Red Blue Set Cover [21, 2, 8]. Our discovery is important for two reasons: (i) from the equivalence reduction we obtain a new algorithm from [11] and (ii) an inapproximability result, showing that polynomial time is very likely to restrict the approximation factor of the problem to ||14 at best. It is important to note that the number of input FDs, denoted as ||, can range from a constant to an exponential function of n. Therefore, our bound does not directly provide a limit based solely on n. Instead, it offers a new form of approximation guarantee. Our findings are summarized in the following theorem.

Theorem 11 (Algorithm and Inapproximability of 1-round TCAND).

The 1-round TCAND problem admits a polynomial time O~(||13)-approximation algorithm and, additionally, does not admit a polynomial time algorithm with approximation ratio better than O~(||14ϵ) unless the Dense-vs-Random conjecture [9] fails. The hardness results carries over to D-round TCAND for any D[n].

We now prove Theorem 11 by proving an equivalence between the 1-round TCAND problem andRed Blue Set Cover and then utilizing the recent progress in [11]. We adopt the same convention regarding the use of red/blue colors as described in the Red Blue Set Cover problem in Section 2.

Proof.

Given a collection of FDs and a set T we create an instance of Red Blue Set Cover as follows. Firstly, for each element iT, we introduce a new variable i(new). Our universe U will be composed of these new variables in addition to the original ones. The new variables will be colored blue whereas the old variables will be colored red. Now, for every FD LSi we create a set SLS:=LS{i(new)} (note that due to the 1-round scenario, we may discard each FD of the form LSi with iT so i(new) is well defined). We claim that any solution to Red Blue Set Cover of size k yields a solution to 1-round TCAND of size k and vice versa. Indeed, if we have a collection of sets 𝒮 that cover all blue points and k red points, we may as well pick the variables corresponding to those red points as our solution. By definition, for every SLS𝒮 we have covered LS and so this means that all blue points are covered as there exists an FD of the form LSi iT and some totally coverd LS, which correspond exactly to T being inferred. Additionally, every solution to 1-round TCAND of size k can be mapped to a Red Blue Set Cover solution by noting that every chosen variable corresponds to a red point and thus we may pick all the sets for which all their red variables are chosen in the solution. This covers all the blue points by the fact that all variables in T can be inferred from the original instance and every blue point corresponds to a variable in T. For the converse, consider an instance of Red Blue Set Cover where U=defRB is the union of a red set R and a blue set B. We can construct an instance of 1-round TCAND as follows: For each set S=def{e1,,et}, we create a functional dependency (FD) SBSB. We then set T=defB and solve the 1-round TCAND problem for this instance. Note that this process may generate FDs of the form V for some non-empty set V.

A solution to the constructed 1-round TCAND instance of size k means that we pick only variables corresponding to red points as the left hand side is of the form SB and in particular at most k of them. Let Rsol be those points and pick the sets S for which SRsol. This means that the chosen sets do not cover points outside of Rsol and hence cover at most k red points. Additionally, every blue point bB is covered by the definition of the target T: the activated FD SBb means that we have picked the set S and bB participates in an activated FD. The other direction is analogous. Finally, note that the number of sets created in the above reductions equals the number of FDs, i.e. ||. Invoking Theorems 13 by Chlamtavc et al. [11] yields the desired results.

4 Integrality Gaps

We complement Theorem 9 by showing that the integrality gap of the problem of the LP relaxation is at least (f12)D1 which is close to what we achieve. Specifically, we prove the following results.

Theorem 12.

(Integrality gap for D-round-TCAND) For f3, the integrality gap of the Linear Programming Formulation for the D-round-TCAND problem is at least

(n/(D+1)12)D=Ω(nD)D.

To be more precise, it is at least f21D1, where f:=maxiV|XV:Xi|. whenever f3. The result holds even when each FD in has a left hand side with cardinality at most 2. For f=2 the problem cannot be approximated within a factor of 2ϵ for any ϵ>0 assuming the Unique Games Conjecture [26].

It is worth pointing out that the integrality gap is not an artifact of our modelling of the problem, since as we showed in Theorem 11, there exists no polynomial time algorithm that can achieve an approximation ratio better than ||14δ with δ>0 under the Dense-vs-Random Conjecture [9] even for D=1. Before presenting the proof of Theorem 12, we first establish Theorem 13, which is a simpler version of the theorem. This preliminary result helps to elucidate the fundamental concept driving the overall proof. In essence, our proof is analogous to the integrality gap of the standard LP relaxation for the vertex cover, which assigns each variable a value of 12 in a clique of n nodes. This approach results in an integrality gap of n1n22 as n [42]. The adaptation to obtain the more general Theorem 12 is straightforward afterwards.

Theorem 13.

The integrality gap of our LP formulation for the D-round TCAND problem is at least 2D.

Proof.

We create an instance of the D-round TCAND problem as follows. Consider the variable set V:=V(0)V(1)V(D) where V(r):={(i,r)}i[5]. Note that we use tuples as variable names. We insert FDs in from some pairs of variables in V(r) to variables in V(r+1) as follows for r=0,,D1. For each variable (k,r+1) in V(r+1), we create two FDs of the form (i,r),(j,r)(k,r+1). Note that |V(r)×V(r)|=(52)=10 pairs of variables in layer r. These 10 pairs are then partitioned into 5 sets, each containing 2 pairs. Each set corresponds to the left-hand side of an FD for a specific variable in the next layer, V(r+1). In other words, for each variable in V(r+1), there are two pairs of variables from V(r) that determine it through FDs. Finally, we set T=V(D) as the target set for this instance. Notice that T(V(0))+.

A feasible fractional solution to our LP formulation is to assign the fractional weight c:=2D+1 to every variable in V(0), i.e. set xi,0(0)=2D+1,i[5]. One can verify that zLS(1):=1 for every LS(i,1) and hence we have that xi,1(1) can be as large as zLS(1)(i,1)c=2c for all i by the fact that every (i,r) variable can be inferred from exactly two FDs. Inductively, we have that xi,d(d) can be as large as 2dc and hence in the last layer we have xi,D(D)=2Dc=1, meaning that every element in the last layer, which is exactly our target set, satisfies the target constraint of our LP. This shows that the total fractional cost is 52D whereas the integral cost is 5, yielding the 2D integrality gap.

It is important to note that our proof employs an inductive approach. However, the underlying intuition becomes more apparent when we consider the process starting from the final layer D and moving backwards. In the final layer, each variable is a target variable, so its corresponding LP variable is set to 1 because of the target constraints. Given that each variable can be inferred by two FDs, an unfavorable yet feasible scenario for the LP would involve equally distributing the weight between these two FDs, and this pattern continues in preceding layers. The complete proof of Theorem 12 essentially extends this concept by adjusting the number of FDs associated with each variable.

Proof of Theorem 12.

To obtain the general hardness on the integrality gap, we note that it suffices to set V(r):={(i,r)}i[g] for some parameter g. Then we can force each variable in V(0),V(1),,V(D) to participate in (g2)/gg12 FDs. Thus, the base of exponent in the fractional magnification per level is g1 in contrast to 2 and thus we may obtain both results by setting g:=n/(D+1) (for a total of gD=n nodes) or g=f=maxiV|XV:Xi| for any f3.

For f=2, we observe that the problem is as hard as the Vertex Cover problem, so it cannot be approximated within a factor 2ϵ for any ϵ>0 assuming the Unique Games Conjecture [25]. To prove the equivalence G(V,E) we create a non-target variable xv for each vertex vV and a target variable xe for each edge eE adding the FD xuxvxe if e:=(u,v). We first observe that any vertex cover in G corresponds trivially to a set of variables which cover all target variables {xe}eE. For the other direction, every set S of variables of size k from which {xe}eE can be inferred we can create a set S~ of size |S~||S|k by substituting each xeS,e:=(u,v) with xu (if xu already in the set) and noting that S~ is a vertex cover for G. The above instances rule out any hope for designing efficient approximation algorithms for TCAND using linear programming based approaches.

5 Conclusion

In this work, we introduce the TCAND problem, a generalization of the well-known minimum candidate key problem [30, 32]. The TCAND problem plays an important role in semantic query optimization. We demonstrate that TCAND, in its general form, is a layered set-cover problem, with each layer representing a stage of FD inference using the given FDs. We formulate the TCAND as an integer program and explore its LP relaxation, both from the perspective of algorithm design and the analysis of integrality gaps. We also examine specific cases of the TCAND problem, such as scenarios where all FDs have at most one attribute on their left-hand side. In cases with one round of inference, the problem aligns with the Red Blue Set Cover, a variant of Set Cover known for its inapproximability. Our study opens a gateway to a host of compelling challenges, with the development of practical heuristics as a promising direction for future research.

References

  • [1] Tatsuya Akutsu and Feng Bao. Approximating minimum keys and optimal substructure screens. In International Computing and Combinatorics Conference, pages 290–299. Springer, 1996. doi:10.1007/3-540-61332-3_163.
  • [2] Michael Alekhnovich, Sam Buss, Shlomo Moran, and Toniann Pitassi. Minimum propositional proof length is NP-hard to linearly approximate. The Journal of Symbolic Logic, 66(1):171–191, 2001. doi:10.2307/2694916.
  • [3] Gabriele Ausiello, Alessandro D’Atri, and Domenico Saccà. Minimal representations of directed hypergraphs and their application to database design. In Algorithm design for computer system design, pages 125–157. Springer, 1984.
  • [4] Giorgio Ausiello, Alessandro D’Atri, and Domenico Saccà. Graph algorithms for functional dependency manipulation. Journal of the ACM (JACM), 30(4):752–766, 1983. doi:10.1145/2157.322404.
  • [5] Gautam Bhargava, Piyush Goel, and Bala Iyer. Efficient processing of outer joins and aggregate junctions. In Proceedings of the Twelfth International Conference on Data Engineering, pages 441–449. IEEE, 1996.
  • [6] Gautam Bhargava, Piyush Goel, and Balakrishna R Iyer. Simplification of outer joins. In Proceedings of the 1995 conference of the Centre for Advanced Studies on Collaborative research, page 7, 1995. URL: https://dl.acm.org/citation.cfm?id=781922.
  • [7] Aditya Bhaskara, Moses Charikar, Eden Chlamtáč, Uriel Feige, and Aravindan Vijayaraghavan. Detecting high log-densities: an O(n14) approximation for densest k-subgraph. In Proceedings of the forty-second ACM symposium on Theory of computing, pages 201–210, 2010. doi:10.48550/arXiv.1001.2891.
  • [8] Robert D. Carr, Srinivas Doddi, Goran Konjevod, and Madhav Marathe. On the red-blue set cover problem. In Proceedings of the Eleventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’00, pages 345–353, USA, 2000. Society for Industrial and Applied Mathematics. URL: http://dl.acm.org/citation.cfm?id=338219.338271.
  • [9] Eden Chlamtáč, Michael Dinitz, and Yury Makarychev. Minimizing the union: Tight approximations for small set bipartite vertex expansion. In Proceedings of the Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms, pages 881–899. SIAM, 2017. doi:10.1137/1.9781611974782.56.
  • [10] Eden Chlamtáč, Michael Dinitz, and Robert Krauthgamer. Everywhere-sparse spanners via dense subgraphs. In 2012 IEEE 53rd Annual Symposium on Foundations of Computer Science, pages 758–767. IEEE, 2012. doi:10.48550/arXiv.1205.0144.
  • [11] Eden Chlamtáč, Yury Makarychev, and Ali Vakilian. Approximating red-blue set cover and minimum monotone satisfying assignment. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2023). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023.
  • [12] Xu Chu, Ihab F Ilyas, Paolo Papotti, and Yin Ye. Ruleminer: Data quality rules discovery. In 2014 IEEE 30th International Conference on Data Engineering, pages 1222–1225. IEEE, 2014. doi:10.1109/ICDE.2014.6816746.
  • [13] Graham Cormode, Howard Karloff, and Anthony Wirth. Set cover algorithms for very large datasets. In Proceedings of the 19th ACM international conference on Information and knowledge management, pages 479–488, 2010. doi:10.1145/1871437.1871501.
  • [14] Irit Dinur and David Steurer. Analytical approach to parallel repetition. In Proceedings of the forty-sixth annual ACM symposium on Theory of computing, pages 624–633, 2014. doi:10.1145/2591796.2591884.
  • [15] Paul Erdős, Alfréd Rényi, et al. On the evolution of random graphs. Publ. math. inst. hung. acad. sci, 5(1):17–60, 1960.
  • [16] Ronald Fagin. Functional dependencies in a relational database and propositional logic. IBM Journal of research and development, 21(6):534–544, 1977.
  • [17] Ronald Fagin and Moshe Vardi. The theory of data dependencies—an overview. In International Colloquium on Automata, Languages, and Programming, pages 1–22. Springer, 1984.
  • [18] Uriel Feige. A threshold of lnn for approximating set cover. Journal of the ACM (JACM), 45(4):634–652, 1998. doi:10.1145/285055.285059.
  • [19] Alan Frieze and Michał Karoński. Random graphs and networks: a first course. Cambridge University Press, 2023.
  • [20] Aristides Gionis and Charalampos E Tsourakakis. Dense subgraph discovery: KDD 2015 tutorial. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pages 2313–2314, 2015. doi:10.1145/2783258.2789987.
  • [21] Michael Goldwasser and Rajeev Motwani. Intractability of assembly sequencing: Unit disks in the plane. In Algorithms and Data Structures: 5th International Workshop, WADS’97 Halifax, Nova Scotia, Canada August 6–8, 1997 Proceedings 5, pages 307–320. Springer, 1997. doi:10.1007/3-540-63307-3_70.
  • [22] András Hajnal and Endŕe Szemerédi. Proof of a conjecture of P. Erdős. Combinatorial theory and its applications, 2:601–623, 1970.
  • [23] Ihab F Ilyas, Xu Chu, et al. Trends in cleaning relational data: Consistency and deduplication. Foundations and Trends® in Databases, 5(4):281–393, 2015. doi:10.1561/1900000045.
  • [24] Richard M Karp. Reducibility among combinatorial problems. Springer, 2010. doi:10.1007/978-3-540-68279-0_8.
  • [25] Subhash Khot and Oded Regev. Vertex cover might be hard to approximate to within 2- ε. Journal of Computer and System Sciences, 74(3):335–349, 2008. doi:10.1109/CCC.2003.1214437.
  • [26] Subhash Khot and Nisheeth K Vishnoi. On the unique games conjecture. In FOCS, volume 5, page 3, 2005. doi:10.1109/SFCS.2005.61.
  • [27] Hal A Kierstead and Alexandr V Kostochka. A short proof of the Hajnal–Szemerédi theorem on equitable colouring. Combinatorics, Probability and Computing, 17(2):265–270, 2008. doi:10.1017/S0963548307008619.
  • [28] Henry A Kierstead, Alexandr V Kostochka, Marcelo Mydlarz, and Endre Szemerédi. A fast algorithm for equitable coloring. Combinatorica, 30(2):217–224, 2010. doi:10.1007/s00493-010-2483-5.
  • [29] Mihail N Kolountzakis, Gary L Miller, Richard Peng, and Charalampos E Tsourakakis. Efficient triangle counting in large graphs via degree-based vertex partitioning. Internet Mathematics, 8(1-2):161–185, 2012. doi:10.1080/15427951.2012.625260.
  • [30] Witold Lipski. Two np-complete problems related to information retrieval. In International Conference on Fundamentals of Computation Theory, pages 452–458. Springer, 1977. doi:10.1007/978-3-662-40153-8_52.
  • [31] László Lovász. On the ratio of optimal integral and fractional covers. Discrete mathematics, 13(4):383–390, 1975. doi:10.1016/0012-365X(75)90058-8.
  • [32] Claudio L Lucchesi and Sylvia L Osborn. Candidate keys for relations. Journal of Computer and System Sciences, 17(2):270–279, 1978. doi:10.1016/0022-0000(78)90009-0.
  • [33] Pasin Manurangsi. Almost-polynomial ratio eth-hardness of approximating densest k-subgraph. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 954–961, 2017. doi:10.1145/3055399.3055412.
  • [34] Glenn N Paulley and Per-Åke Larson. Exploiting uniqueness in query optimization. In CASCON First Decade High Impact Papers, CASCON ’10, pages 127–145, USA, 2010. IBM Corp. doi:10.1145/1925805.1925812.
  • [35] Glenn Norman Paulley. Exploiting Functional Dependence in Query Optimization. PhD thesis, University of Waterloo, 2001.
  • [36] Sriram Pemmaraju and Aravind Srinivasan. The randomized coloring procedure with symmetry-breaking. In Automata, Languages and Programming: 35th International Colloquium, ICALP 2008, Reykjavik, Iceland, July 7-11, 2008, Proceedings, Part I 35, pages 306–319. Springer, 2008. doi:0.1007/978-3-540-70575-8_26.
  • [37] Raghu Ramakrishnan and Johannes Gehrke. Database management systems, volume 3. McGraw-Hill New York, 2003.
  • [38] Hossein Saiedian and Thomas Spencer. An efficient algorithm to compute the candidate keys of a relational database schema. The Computer Journal, 39(2):124–132, 1996. doi:10.1093/COMJNL/39.2.124.
  • [39] Petr Slavík. A tight analysis of the greedy algorithm for set cover. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pages 435–441, 1996. doi:10.1145/237814.237991.
  • [40] Robert Tarjan. Depth-first search and linear graph algorithms. SIAM journal on computing, 1(2):146–160, 1972. doi:10.1137/0201010.
  • [41] Vijay V Vazirani. Approximation algorithms, volume 1. Springer, 2001.
  • [42] David P Williamson and David B Shmoys. The design of approximation algorithms. Cambridge university press, 2011.
  • [43] Laurence A Wolsey. Integer programming. John Wiley & Sons, 2020.