Query Hierarchy Research Articles

A novel approach to hierarchical contextual bipolar queries: A winnow operator approach

Abstract We propose a new approach to the bipolar database queries, which involve a necessary (required) and optional (desired) conditions, connected with a non-conventional aggregation operator “and possibly”, combined with a context, exemplified by “find houses which are cheap and – with respect to other houses in town – possibly close to a railroad station”. We use our winnow operator based interpretation of the bipolar queries. We assume that the query, posed by the human user, involves terms, which do not directly relate to attributes, and which are then to be decoded using a concept of a query hierarchy, leading to the queries, which involve terms directly related to attribute values. The original query is considered to be of level 0, at the bottom of the precisiation hierarchy, then its required and optional parts are assumed to be bipolar queries themselves, both accounting for context. The precisiation proceeds further, to level 1 queries, level 2, etc. A real estate related example is provided as illustration.

Supporting Scalable and Adaptive Metadata Management in Ultralarge-Scale File Systems

This paper presents a scalable and adaptive decentralized metadata lookup scheme for ultralarge-scale file systems (more than Petabytes or even Exabytes). Our scheme logically organizes metadata servers (MDSs) into a multilayered query hierarchy and exploits grouped Bloom filters to efficiently route metadata requests to desired MDSs through the hierarchy. This metadata lookup scheme can be executed at the network or memory speed, without being bounded by the performance of slow disks. An effective workload balance method is also developed in this paper for server reconfigurations. This scheme is evaluated through extensive trace-driven simulations and a prototype implementation in Linux. Experimental results show that this scheme can significantly improve metadata management scalability and query efficiency in ultralarge-scale storage systems.

Extending stratified datalog to capture complexity classes ranging from ${\cal P} to {\cal QH}$

This paper presents a unified solution to the problem of extending stratified DATALOG to express database complexity classes ranging from \({\cal P} to {\cal QH}; {\cal QH}\) is the query hierarchy containing the decision problems that can be solved in polynomial time by a deterministic Turing machine using a constant number of calls to an \({\cal NP}\)-oracle. The solution is based on (i) stratified negation as the core of a simple, declarative semantics for negation, (ii) the use of a “choice” construct to capture the nondeterminism of stable models in a disciplined fashion, (iii) the ability to bind a query to the lowest complexity level that includes the problem at hand, and (iv) a general algorithm that adapts its behavior to the desired level of complexity required by the query so that exponential time computation is only required for hard problems.

Oracles That Compute Values

This paper focuses on complexity classes of partial functions that are computed in polynomial time with oracles in NPMV, the class of all multivalued partial functions that are computable nondeterministically in polynomial time. Concerning deterministic polynomial-time reducibilities, it is shown that a multivalued partial function is polynomial-time computable with k adaptive queries to NPMV if and only if it is polynomial-time computable via 2k-1 nonadaptive queries to NPMV; a characteristic function is polynomial-time computable with k adaptive queries to NPMV if and only if it is polynomial-time computable with k adaptive queries to NP; unless the Boolean hierarchy collapses, for every k, k adaptive (nonadaptive) queries to NPMV are different than k+1 adaptive (nonadaptive) queries to NPMV. Nondeterministic reducibilities, lowness, and the difference hierarchy over NPMV are also studied. The difference hierarchy for partial functions does not collapse unless the Boolean hierarchy collapses, but, surprisingly, the levels of the difference and bounded query hierarchies do not interleave (as is the case for sets) unless the polynomial hierarchy collapses.

The Boolean Hierarchy and the Polynomial Hierarchy: A Closer Connection

We show that if the Boolean hierarchy collapses to level $k$, then the polynomial hierarchy collapses to $BH_{3}(k)$, where $BH_{3}(k)$ is the $k$th level of the Boolean hierarchy over $\Sigma^{P}_{2}$. This is an improvement over the known results, which show that the polynomial hierarchy would collapse to $P^{NP^{NP}[O(\log n)]}$. This result is significant in two ways. First, the theorem says that a deeper collapse of the Boolean hierarchy implies a deeper collapse of the polynomial hierarchy. Also, this result points to some previously unexplored connections between the Boolean and query hierarchies of $Delta^{P}_{2}$ and $Delta^{P}_{3}$. Namely, \begin{eqnarray*} & BH(k) = {\rm co-}BH(k) \implies BH_{3}(k) = {\rm co-}BH_{3}(k), \\[\jot] & P^{{\rm NP}\|[k]} = P^{{\rm NP}\|[k+1]} \implies P^{{\rm NP}^{\rm NP}\|[k+1]} = P^{{\rm NP}^{\rm NP}\|[k+2]}. \end{eqnarray*}

Saving Queries with Randomness

In this paper, we investigate the power of randomness to save a query to an NP-complete set. We show that the PSAT ∥ [k] ≤pm-complete language randomly reduces to a language in PSAT ∥ [k − 1] with a one-sided error probability of 1/⌈k/2⌉ or a two sided-error probability of 1/(k+1). Furthermore, we prove that these probability bounds are tight; i.e., they cannot be improved by 1/poly, unless PH collapses. We also obtain tight performance bounds for randomized reductions between nearby classes in the Boolean and bounded query hierarchies. These bounds provide probability thresholds for completeness under randomized reductions in these classes. Using these thresholds, we show that certain languages in the Boolean hierarchy which are not ≤pm-complete in some relativized worlds, nevertheless inherit many of the hardness properties associated with the ≤pm-complete languages. Finally, we explore the relationship between randomization and functions that are computable using bounded queries to SAT. For any function h(n) = O(log n), we show that there is a function f computable using h(n) nonadaptive queries to SAT, which cannot be computed correctly with probability 1/2 + 1/poly by any randomized machine which makes less than h(n) adaptive queries to any oracle, unless PH collapses.

On computing Boolean connectives of characteristic functions

This paper is a study of the existence of polynomial time Boolean connective functions for languages. A languageL has an AND function if there is a polynomial timef such thatf(x,y) eL ⇔x eL andy e L. L has an OR function if there is a polynomial timeg such thatg(x,y) e⇔xeL oryeL. While all NP complete sets have these functions, Graph Isomorphism, which is probably not complete, is also shown to have both AND and OR functions. The results in this paper characterize the complete sets for the classes Dp and pSAT[O(logn)] in terms of AND and OR and relate these functions to the structure of the Boolean hierarchy and the query hierarchies. Also, this paper shows that the complete sets for the levels of the Boolean hierarchy above the second level cannot have AND or OR unless the polynomial hierarchy collapses. Finally, most of the structural properties of the Boolean hierarchy and query hierarchies are shown to depend only on the existence of AND and OR functions for the NP complete sets.

PP Is Closed under Intersection

In this seminal paper on probabilistic Turing machines, Gill asked whether the class PP is closed under intersection and union. We give a positive answer to this question. We also show that PP is closed under a variety of polynomial-time truth-table reductions. Consequences in complexity theory include the definite collapse and (assuming P ≠ PP) separation of certain query hierarchies over PP. Similar techniques allow us to combine several threshold gates into a single threshold gate. Consequences in the study of circuits include the simulation of circuits with a small number of threshold gates by circuits having only a single threshold gate at the root (perceptrons) and a lower bound on the number of threshold gates that are needed to compute the parity function.

Bounded queries to SAT and the Boolean hierarchy

We study the complexity of decision problems that can be solved by a polynomial-time Turing machine that makes a bounded number of queries to an NP oracle. Depending on whether we allow some queries to depend on the results of other queries, we obtain two (probably) different hierarchies. We present several results relating the bounded NP query hierarchies to each other and to the Boolean hierarchy. We also consider the similarly defined hierarchies of functions that can be computed by a polynomial-time Turing machine that makes a bounded number of queries to an NP oracle. We present relations among these two hierarchies and the Boolean hierarchy. In particular we show for all k that there are functions computable with 2 k parallel queries to an NP set that are not computable in polynomial time with k serial queries to any oracle, unless P = NP. As a corollary k + 1 parallel queries to an NP set allow us to compute more functions than are computable with only k parallel queries to an NP set, unless P = NP; the same is true of serial queries. Similar results hold for all tt-self-reducible sets. Using a “mind-change” technique, we show that 2 k - 1 parallel queries to an NP set allow us to accept in polynomial time exactly the same sets as can be accepted in polynomial time with k serial queries to an NP set. (In fact, the same is true for any class in place of NP that is closed under polynomial-time positive-bounded-truth-table reductions.) This contrasts with the expected result for function computations with an NP oracle (Beigel, 1988). In addition we show that the Boolean hierarchy and the bounded query hierarchies (of languages) either stand or collapse together. Finally we show that if the Boolean hierarchy collapses to any level but the zeroth (deterministic polynomial time), then for all k there are functions computable in polynomial time with k parallel queries to an NP set that are not computable in polynomial time with k - 1 serial queries to any set (NP-complete sets are p-superterse).

Relational queries computable in polynomial time

We characterize the polynomial time computable queries as those expressible in relational calculus plus a least fixed point operator and a total ordering on the universe. We also show that even without the ordering one application of fixed point suffices to express any query expressible with several alternations of fixed point and negation. This proves that the fixed point query hierarchy suggested by Chandra and Harel collapses at the first fixed point level. It is also a general result showing that in finite model theory one application of fixed point suffices.

Structure and complexity of relational queries

This paper is an attempt at laying the foundations for the classification of queries on relational data bases according to their structure and their computational complexity. Using the operations of composition and fixpoints, a Σ-π hierarchy of height ω 2, called the fixpoint query hierarchy, is defined, and its properties investigated. The hierarchy includes most of the queries considered in the literature including those of Codd and Aho and Ullman. The hierarchy to level ω characterizes the first-order queries, and the levels up to ω are shown to be strict. Sets of queries larger than the fixpoint query hierarchy are obtained by considered the queries computable in polynomial time, queries computable in polynomial space, etc. It is shown that classes of queries defined from such complexity classes behave (with respect to containment) in a manner very similar to the corresponding complexity classes. Also, the set of second-order queries turns out to be the same as the set of queries defined from the polynomial-time hierarchy. Finally, these classes of queries are used to analyse a set of queries defined from language considerations: those expressible in a programming language with only typed (or ranked) relation variables.