Functional dependencies among Boolean dependencies

This paper presents a PAC learning framework for inferring a set of functional dependencies from example tuples. A simple algorithm which outputs a set of all the functional dependencies consistent with example tuples is considered. Let T be a set of the whole tuples. The error is defined as the minimum \(\sum\limits_{t \in V} {p\left( t \right)}\) where V is a set such that a set of functional dependencies is consistent with T−V and p(t) denotes the probability of a tuple t. The number of examples required to infer a set of functional dependencies whose error does not exceed e with probability at least 1−δ under an arbitrary probability distribution is shown to be \(O(\frac{{\sqrt {\ln \tfrac{1}{\delta }} }}{\varepsilon }\sqrt {\left| T \right|} )\).

Relational model is the most essential database model for decades and is examined in various ways. A very important concept in the relational modeling is the concept of dependencies. Particularly a set of functional dependencies and its equivalent minimal cover are discussed here for synthesizing third normal form relations. A traditional synthesis algorithm have been used to reduce the set of functional dependencies, F, into an equivalent minimal cover. This cover is then used to develop a relational schema; however, a given set of functional dependencies may have more than one minimal covers. In turn, different minimal covers may give rise to different relational schema. Database designers had already been agreed upon the use of popular inference rules of Armstrong to obtain minimal covers from the set F of functional dependencies. Despite the frequent use of the traditional synthesis algorithm, there is still a lack of formality and simplicity support in that algorithm to produce a minimum cover, especially; the step(s) of the algorithm in which the set of functional dependencies of F are used to make left-irreducible remain informal. In this paper, an extension is proposed to the synthesis algorithm that aids in to produce an optimal minimal cover more systematically from the given set of functional dependencies. The optimal minimal cover obtained by this extension would be appropriate for synthesizing third normal form relational schema from the universal relation scheme.

Characterizations for functional dependency and Boyce-Codd normal form families

Axiomatisation of functional dependencies in incomplete relations

Most algorithms in relational database theory use a set of functional dependencies as their input. The efficiency of the algorithms depends on the size of the set. The notions of a minimum set (with as few dependencies as possible) and an optimum set (which is as short as possible) were introduced by Maier. He showed that while a minimum cover for a given set of dependencies can be found in polynomial time, obtaining an optimum cover is an NP-complete problem. Here the relationship of these covers is explored further. It is shown that the length of a minimum set (i) cannot be bounded by a linear function on the length of an optimum cover, and (ii) is bounded by the square of the length of an optimum cover. It is also shown that the NP-completeness of the optimization problem is somewhat surprisingly caused solely by the difficulty of optimizing a single class of dependencies having equivalent left sides, not by the globality of the optimality condition. This result has some practical significance, since the equivalence classes appearing in practice are short. The problem of optimizing an equivalence class is studied and left and right sides of a dependency are shown to behave differently. A new representation for equivalence classes based on this observation is suggested. The optimization of single dependencies is shown to be NP-complete, and a method to produce good approximations is given.

On learning multivalued dependencies with queries

Let R be a γ-acyclic relational scheme, and let F be the set of functional dependencies (FD's) embodied in R. Given an existence constrained database r over R, it was shown in [1] that it is possible to connect tuples from different relations in r and construct a universal instance L, possibly containing null values δ, such that the total projection of L onto R yields exactly the set r. Moreover, conditions were given which guarantee that this L would satisfy the functional dependency with nulls (NFD) counterparts of FD's, in F. The purpose of this note is to generalize the latter result and show that under the same conditions, L actually satisfies NFD counterparts of FD's in the closure F+ of F.

Normal forms and syntactic completeness proofs for functional independencies

In its traditional definition, a repair of an inconsistent database is a consistent database that differs from the inconsistent one in a minimal way. Often, repairs are not equally legitimate, as it is desired to prefer one over another; for example, one fact is regarded more reliable than another, or a more recent fact should be preferred to an earlier one. Motivated by these considerations, researchers have introduced and investigated the framework of preferred repairs, in the context of denial constraints and subset repairs. There, a priority relation between facts is lifted towards a priority relation between consistent databases, and repairs are restricted to the ones that are optimal in the lifted sense. Three notions of lifting (and optimal repairs) have been proposed: Pareto, global, and completion. In this paper we investigate the complexity of deciding whether the priority relation suffices to clean the database unambiguously, or in other words, whether there is exactly one optimal repair. We show that the different lifting semantics entail highly different complexities. Under Pareto optimality, the problem is coNP-complete, in data complexity, for every set of functional dependencies (FDs), except for the tractable case of (equivalence to) one FD per relation. Under global optimality, one FD per relation is still tractable, but we establish Pi-2-p-completeness for a relation with two FDs. In contrast, under completion optimality the problem is solvable in polynomial time for every set of FDs. In fact, we present a polynomial-time algorithm for arbitrary conflict hypergraphs. We further show that under a general assumption of transitivity, this algorithm solves the problem even for global optimality. The algorithm is extremely simple, but its proof of correctness is quite intricate.

Conditional functional dependencies (CFDs) have recently been proposed as a useful integrity constraint to summarize data semantics and identify data inconsistencies. A CFD augments a functional dependency (FD) with a pattern tableau that defines the context (i.e., the subset of tuples) in which the underlying FD holds. While many aspects of CFDs have been studied, including static analysis and detecting and repairing violations, there has not been prior work on generating pattern tableaux, which is critical to realize the full potential of CFDs. This paper is the first to formally characterize a "good" pattern tableau, based on naturally desirable properties of support, confidence and parsimony. We show that the problem of generating an optimal tableau for a given FD is NP-complete but can be approximated in polynomial time via a greedy algorithm. For large data sets, we propose an "on-demand" algorithm providing the same approximation bound, that outperforms the basic greedy algorithm in running time by an order of magnitude. For ordered attributes, we propose the range tableau as a generalization of a pattern tableau, which can achieve even more parsimony. The effectiveness and efficiency of our techniques are experimentally demonstrated on real data.

On completing tables to satisfy functional dependencies

It is well known that faithful (i.e. dependency preserving) decompositions of relational database schemas into Boyce-Codd Normal Form (BCNF) do not always exist, depending on the set of functional dependencies given, and that the corresponding decision problem is NP-hard. The only algorithm to guarantee both faithfulness and BCNF (if possible) proposed so far in [Os79] is a brute-force approach which always requires exponential time. To be useful in practice, e.g. in automated design tools, we require more efficient means.In this paper we present an algorithm which always finds a faithful BCNF decomposition if one exists, and which is usually efficient, and exponential only in notorious cases.

In order to accurately identify Linear Parameter-Varying (LPV) systems, order selection of LPV linear regression models has prime importance. Existing identification approaches in this context suffer from the drawback that a set of functional dependencies needs to be chosen a priori for the parametrization of the model coefficients. However in a black-box setting, it has not been possible so far to decide which functions from a given set are required for the parametrization and which are not. To provide a practical solution, a nonnegative garrote approach is applied. It is shown that using only a measured data record of the plant, both the order selection and the selection of structural coefficient dependence can be solved by the proposed method.

Managing inconsistency in databases has long been recognized as an important problem. One of the most promising approaches to coping with inconsistency in databases is the framework of database repairs, which has been the topic of an extensive investigation over the past several years. Intuitively, a repair of an inconsistent database is a consistent database that differs from the given inconsistent database in a minimal way. So far, most of the work in this area has addressed the problem of obtaining the consistent answers to a query posed on an inconsistent database. Repair checking is the following decision problem: given two databases r and r′, is r′ a repair of r? Although repair checking is a fundamental algorithmic problem about inconsistent databases, it has not received as much attention as consistent query answering. In this paper, we give a polynomial-time algorithm for subset-repair checking under integrity constraints that are the union of a weakly acyclic set of local-as-view (LAV) tuple-generating dependencies and a set of equality-generating dependencies. This result significantly generalizes earlier work for subset-repair checking when the integrity constraints are the union of an acyclic set of inclusion dependencies and a set of functional dependencies. We also give a polynomial-time algorithm for symmetric-difference repair checking, when the integrity constraints form a weakly acyclic set of LAV tgds. After this, we establish a number of complexity-theoretic results that delineate the boundary between tractability and intractability for the repair-checking problem. Specifically, we show that the aforementioned tractability results are optimal; in particular, subset-repair checking for arbitrary weakly acyclic sets of tuple-generating dependencies is a coNP-complete problem. We also study cardinality-based repairs and show that cardinality-repair checking is coNP-complete for various classes of integrity constraints encountered in database design and data exchange. Copyright 2009 ACM.

A Combined Framework for Grouping and Order Optimization