pinecone/core-2020-05-10-deduplication huggingface dataset:
Learning from a Consistently Ignorant Teacher

AbstractOne view of computational learning theory is that of a learner acquiring the knowledge of a teacher. We introduce a formal model of learning capturing the idea that teachers may have gaps in their knowledge. In particular, we consider learning from a teacher who labels examples “+” (a positive instance of the concept being learned), “−” (a negative instance of the concept being learned), and “?” (an instance with unknown classification), in such a way that knowledge of the concept class and all the positive and negative examples is not sufficient to determine the labelling of any of the examples labelled with “?”. The goal of the learner is not to compensate for the ignorance of the teacher by attempting to infer “+” or “−” labels for the examples labelled with “?”, but is rather to learn (an approximation to) the ternary labelling presented by the teacher. Thus, the goal of the learner is still to acquire the knowledge of the teacher, but now the learner must also identify the gaps. This is the notion of learning from a consistently ignorant teacher. We present general results describing when known learning algorithms can be used to obtain algorithms that learn from a consistently ignorant teacher. We investigate the learnability of a variety of concept classes in this model, including monomials, monotone DNF formulas, Horn sentences, decision trees, DFAs, and axis-parallel boxes in Euclidean space, among others. Both learnability and non-learn- ability results are presented
Normal Forms and Conservative Extension Properties for Query Languages over Collection Types

AbstractStrong normalization results are obtained for a general language for collection types. An induced normal form for sets and bags is then used to show that the class of functions whose input has height (that is, the maximal depth of nestings of sets/bags/lists in the complex object) at mostiand output has height at mostodefinable in a nested relational query language withoutpowersetoperator isindependentof the height of intermediate expressions used. Our proof holds regardless of whether the language is used for querying sets, bags, or lists, even in the presence of variant types. Moreover, the normal forms are useful in a general approach to query optimization. Paredaens and Van Gucht (ACM Trans on Database Systems17, No.?1 (1992), 65–93), proved a similar result for the special case wheni=o=1. Their result is complemented by Hull and Su (J. Comput. Systems Sci.43(1991), 219–261) who demonstrated the failure of independence when powerset operator is present andi=o=1. The theorem of Hull and Su was generalized to alliandoby Grumbach and Vianu (in“Proceedings of the 3rd International Conference on Database Theory,” Lecture Notes in Computer Science, Vol.?470, Springer-Verlag, Berlin, 1990). Our result generalizes Paredaens and Van Gucht's to alliando, providing a counterpart to the theorem of Grumbach and Vianu
An Extension of Van Gelder's Alternating Fixpoint to Magic Programs

AbstractWe study the application of the magic-sets transformation technique to Datalog⌝(function-free programs with negation) that may not have two-valued well-founded models. In this general setting, the well-founded model of the original program does not always agree with the well-founded model of the magic program derived by commonly used left-to-right sideways information-passing strategies on the query. In order to correct this disagreement we present a novel method that is obtained by slightly and naturally tailoring Van Gelder's alternating fixpoint technique to any magic program
Completeness Results for Recursive Data Bases

AbstractWe consider infinite recursive (i.e., computable) relational data bases. Since the set of computable queries on such data bases is not closed under even simple relational operations, one must either make do with a very modest class of queries or considerably restrict the class of allowed data bases. We define two query languages, one for each of these possibilities, and prove their completeness. The first is the language of quantifier-free first-order logic, which is shown to be complete for the non-restricted case. The second is an appropriately modified version of Chandra and Harel's language QL, which is proved complete for the case of “highly symmetric” data bases, i.e., ones whose set of automorphisms is of finite index for each tuple width. We also address the related notion of BP-completeness
Selectivity and Cost Estimation for Joins Based on Random Sampling

AbstractWe compare the performance of sampling-based procedures for estimating the selectivity of a join. While some of the procedures have been proposed in the database literature, their relative performance has never been analyzed. A main result of this paper is a partial ordering that compares the variability of the estimators for the different procedures after an arbitrary fixed number of sampling steps. Prior to the current work, it was also unknown whether these fixed-step procedures could be extended to fixed-precision procedures that are both asymptotically consistent and asymptotically efficient. Our second main result is a general method for such an extension and a proof that the method is valid for all the procedures under consideration. We show that, under plausible assumptions on sampling costs, the partial ordering of the fixed-step procedures with respect to variability of the selectivity estimator implies a partial ordering of the corresponding fixed-precision procedures with respect to sampling cost. Our final result is a collection of fixed-step and fixed-precision procedures for estimating the cost of processing a join query according to a fixed join plan
Towards Tractable Algebras for Bags

AbstractBags, i.e., sets with duplicates, are often used to implement relations in database systems. In this paper, we study the expressive power of algebras for manipulating bags. The algebra we present is a simple extension of the nested relation algebra. Our aim is to investigate how the use of bags in the language extends its expressive power and increases its complexity. We consider two main issues, namely (i) the impact of the depth of bag nesting on the expressive power and (ii) the complexity and the expressive power induced by the algebraic operations. We show that the bag algebra is more expressive than the nested relation algebra (at all levels of nesting), and that the difference may be subtle. We establish a hierarchy based on the structure of algebra expressions. This hierarchy is shown to be highly related to the properties of the powerset operator
Indexing for Data Models with Constraints and Classes

AbstractWe examine I/O-efficient data structures that provide indexing support for new data models. The database languages of these models include concepts from constraint programming (e.g., relational tuples are generated to conjunctions of constraints) and from object-oriented programming (e.g., objects are organized in class hierarchies). Letnbe the size of the database,cthe number of classes,Bthe page size on secondary storage, andtthe size of the output of a query: (1) Indexing by one attribute in many constraint data models is equivalent to external dynamic interval management, which is a special case of external dynamic two-dimensional range searching. We present a semi-dynamic data structure for this problem that has worst-case spaceO(n/B) pages, query I/O timeO(logBn+t/B) andO(logBn+(logBn)2/B) amortized insert I/O time. Note that, for the static version of this problem, this is the first worst-case optimal solution. (2) Indexing by one attribute and by class name in an object-oriented model, where objects are organized as a forest hierarchy of classes, is also a special case of external dynamic two-dimensional range searching. Based on this observation, we first identify a simple algorithm with good worst-case performance, query I/O timeO(log2clogBn+t/B), update I/O timeO(log2clogBn) and spaceO((n/B)log2c) pages for the class indexing problem. Using the forest structure of the class hierarchy and techniques from the constraint indexing problem, we improve its query I/O time toO(logBn+t/B+log2B)
AnO(n) Algorithm for Abelianp-Group Isomorphism and anO(nlogn) Algorithm for Abelian Group Isomorphism

AbstractThe isomorphism problem for groups is to determine whether two finite groups are isomorphic. The groups are assumed to be represented by their multiplication tables. Tarjan has shown that this problem can be done in timeO(nlogn+O(1)) for groups of cardinalityn. Savage has claimed an algorithm for showing that if the groups are Abelian, isomorphism can be determined in timeO(n2). We improve this bound and give anO(nlogn) algorithm for Abelian group isomorphism. Further, we show that if the groups are Abelianp-groups then isomorphism can be determined in timeO(n). We also show that the elementary divisor sequence for an Abelian group can be determined in timeO(nlogn) and for an Abelianp-group it can be determined in timeO(n)
Automaticity I: Properties of a Measure of Descriptional Complexity

AbstractLetΣandΔbe nonempty alphabets withΣfinite. Letfbe a function mappingΣ* toΔ. We explore the notion ofautomaticity, which attempts to model how “close”fis to a finite-state function. Formally, the automaticity offis a functionAf(n) which counts the minimum number of states in any deterministic finite automaton that computesfcorrectly on all strings of length ⩽n(and its behavior on longer strings is not specified). We defineAL(n) for languagesLto beAχL(n), whereχLis the characteristic function ofL. The same or similar notions were examined previously by Trakhtenbrot, Grinberg and Korshunov, Karp, Breitbart, Gabarró, Dwork and Stockmeyer, and Kaneps and Freivalds. Karp proved that ifL⊆Σ* is not regular, thenAL(n)⩾(n+3)/2 infinitely often. We prove that the lower bound is best possible. We obtain results on the growth rate ofAf(n). If |Σ|=k⩾2 and |Δ|=l<∞, thenAf(n)⩽C(1+o(1))kn+2/nforC=(logkl)/(k−1)2. Also, for almost all functionsfand anyε>0 we haveAf(n)>(1−ε)Ckn+1/nfor all sufficiently largen. We also obtain bounds onNL(n), the nondeterministic automaticity function. This is similar toAf(n), except that it counts the number of states in the minimal NFA, and it is defined for languagesL⊆Σ*. For |Σ|=k⩾2, we haveNL(n)=O(kn/2). Also, for almost all languagesLand everyε>0 we have [formula]for all sufficiently largen. We prove some incomparability results between the automaticity measure and those defined earlier by Gabarró and others. Finally, we examine the notion of automaticity as applied to sequences
New Lower Bounds and Hierarchy Results for Restricted Branching Programs

AbstractIn unrestricted branching programs all variables may be tested arbitrarily often on each path. But exponential lower bounds are only known if on each path the number of tests of each variable is bounded. We examine branching programs in which for each path the number of variables that are tested more than once is bounded bykbut we do not bound the number of tests of those variables. Using a new lower bound method we can prove that such branching programs become more powerful by increasingkonly by 1: Fork⩽(1−ε)(n/3)(1/3)/log2/3n, whereε>0, we exhibit Boolean functions that can be represented in polynomial size ifkvariables may be tested more than once on each path, but only in exponential size ifk−1 variables may be tested more than once on each path. Therefore, we obtain a tight hierarchy
Incremental Learning from Positive Data

AbstractThe present paper deals with a systematic study of incremental learning algorithms. The general scenario is as follows. Letcbe any concept; then every infinite sequence of elements exhaustingcis calledpositive presentationofc. An algorithmic learner successively takes as input one element of a positive presentation as well as its previously made hypothesis at a time and outputs a new hypothesis about the target concept. The sequence of hypotheses has to converge to a hypothesis correctly describing the concept to be learned. This basic scenario is referred to asiterative learning. Iterative inference can be refined by allowing the learner to store ana prioribounded number of carefully chosen examples resulting inbounded example memory inference. Additionally,feed-backidentification is introduced. Now, the learner is enabled to ask whether or not a particular element did already appear in the data provided so far. Our results are threefold: First, the learning capabilities of the various models of incremental learning are related to previously studied learning models. It is proved that incremental learning can be always simulated by inference devices that are both set-driven and conservative. Second, feed-back learning is shown to be more powerful than iterative inference, and its learning power is incomparable to that of bounded example memory inference which itself extends that of iterative learning, too. In particular, the learning power of bounded example memory inference always increases if the number of examples the learner is allowed to store is incremented. Third, a sufficient condition for iterative inference allowingnon-enumerativelearning is provided. The results obtained provide strong evidence that there is no unique way to design superior incremental learning algorithms. Instead, incremental learning is the art of knowing what to overlook
Limits on the Power of Parallel Random Access Machines with Weak Forms of Write Conflict Resolution

AbstractThe ROBUST PRAM is a concurrent-read concurrent-write (CRCW) parallel random access machine in which any value might appear in a memory cell as a result of a write conflict. This paper addresses the question of whether a PRAM with such a weak form of write conflict resolution can compute functions faster than the concurrent-read exclusive-write (CREW) PRAM. We prove a lower bound on the time required by the ROBUST PRAM to compute Boolean functions in terms of the number of different values each memory cell of the PRAM can contain and the degree of the function when expressed as a polynomial over a finite field. In the case of 1-bit memory cells, our lower bound for the problem of computing the OR ofnBoolean variables exactly matches Cook, Dwork, and Reischuk's upper bound on the CREW PRAM. We extend our result to obtain a lower bound, depending on the number of processors, for computing Boolean functions on the ROBUST PRAM, even with memory cells of unbounded size. A ?particular consequence is that the ROBUST PRAM with[formula]processors requires[formula]steps to compute OR. These results are obtained by defining a class of CRCW PRAMs, the fixed adversary PRAMs, all of which are at least as powerful as the ROBUST PRAM. We prove our lower bounds using carefully chosen PRAMs from this class. We also show the limitations of this technique by describing how, withn-bit memory cells, any fixed adversary PRAM can compute OR and, more generally, simulate a PRIORITY PRAM in constant time. Finally, we consider the effect of adding randomization to the ROBUST PRAM. For any algorithm that computes OR without error, its expected running time on its worst input is no better than the worst case deterministic time complexity of computing OR. However, allowing a small probability of error enables the ROBUST PRAM with single bit memory cells to compute OR in almost constant time
Towards Structured Parallel Computing on Architecture-Independent Parallel Algorithm Design for Distributed-Memory Architectures

AbstractThis paper introduces an architecture-independent, hierarchical approach to algorithm design on distributed-memory architectures, in contrast to the current trend of tailoring algorithms towards specific architectures. We show that, rather surprisingly, this new approach can achieve uniformity without sacrificing efficiency. In our framework, there are three levels of algorithm design: design of a network-independent algorithm in a network-independent programming environment, design of virtual networks (virtual architectures) for the algorithm, and design of emulations of the virtual networks on physical networks. In its organizational principle, this methodology is analogous to the abstract data structure approach to sequential algorithm design. We propose the following thesis: architecture-independent optimality can lead to portable optimality. Namely, a single network-independent algorithm, when optimized network-independently, with the support of properly chosen virtual networks, can be implemented on a wide spectrum of physical networks to achieve optimality on each of them with respect to both computation and communication. We illustrate this thesis with an analysis of the example of algorithm design for ordinary matrix multiplication. In a paper by Gao, a general theory of portable optimality of parallel algorithms is presented. Besides its implications to the methodology of parallel algorithm design, our framework also suggests new questions for theoretical research in parallel computation on interconnection networks
Efficient Theoretic and Practical Algorithms for Linear Matroid Intersection Problems

AbstractEfficient algorithms for the matroid intersection problem, both cardinality and weighted versions, are presented. The algorithm for weighted intersection works by scaling the weights. The cardinality algorithm is a special case, but takes advantage of greater structure. Efficiency of the algorithms is illustrated by several implementations on linear matroids. Consider a linear matroid withmelements and rankn. Assume all element weights are integers of magnitude at mostN. Our fastest algorithms use timeO(mn1.77log(nN)) andO(mn1.62) for weighted and unweighted intersection, respectively; this improves the previous best bounds,O(mn2.4) andO(mn2logn), respectively. Corresponding improvements are given for several applications of matroid intersection to numerical computation and dynamic systems
On Limited Nondeterminism and the Complexity of the V-C Dimension

AbstractWe characterize precisely the complexity of several natural computational problems in NP, which have been proposed but not categorized satisfactorily in the literature: Computing the Vapnik–Chervonenkis dimension of a 0–1 matrix; finding the minimum dominating set of a tournament; satisfying a Boolean expression by perturbing the default truth assignment; and several others. These problems can be solved innO(logn)time, and thus, they are probably not NP-complete. We define two new complexity classes between P and NP, very much in the spirit of MAXNP and MAXSNP. We show that computing the V–C dimension is complete for the more general class, while the other two problems are complete for the weaker class
Taking It to the Limit: On Infinite Variants of NP-Complete Problems

AbstractWe define infinite, recursive versions of NP optimization problems. For example,Max Cliquebecomes the question of whether a recursive graph contains an infinite clique. The present paper was motivated by trying to understand what makes some NP problems highly undecidable in the infinite case, while others remain on low levels of the arithmetical hierarchy. We prove two results; one enables using knowledge about the infinite case to yield implications to the finite case, and the other enables implications in the other direction. Moreover, taken together, the two results provide a method for proving (finitary) problems to be outside the syntactic classMaxNP, and, hence, outsideMaxSNP too, by showing that their infinite versions areΣ11-complete. We illustrate the technique with many examples, resulting ?in a large number of newΣ11-complete problems
P-Selective Sets and Reducing Search to Decision vs Self-Reducibility

AbstractWe distinguish self-reducibility of a languageLwith the question of whether search reduces to decision forL. Results include: (i) If NE≠E, then there exists a setLin NP−P such that search reduces to decision forL, search doesnotnonadaptively reduce to decision forLandLis not self-reducible. (ii) If UE≠E, then there exists a languageL∈UP−P such that search nonadaptively reduces to decision for L, but L is not self-reducible. (iii) If UE∩co-UE≠E, then there is a disjunctive self-reducible languageL∈UP−P for which search doesnotnonadaptively reduce to decision. We prove that if NE⊈BPE, then there is a languageL∈NP−BPP such thatLis randomly self-reducible,notnonadaptively randomly self-reducible, andnotself-reducible. We obtain results concerning trade-offs in multiprover interactive proof systems and results that distinguish checkable languages from those that are nonadaptively checkable. Many of our results are proven by constructing p-selective sets. We obtain a p-selective set that isnot⩽Ptt-equivalent to any tally language, and we show that if P=PP, then every p-selective set is ⩽PT-equivalent to a tally language. Similarly, if P=NP, then every cheatable set is ⩽Pm-equivalent to a tally language. We construct a recursive p-selective tally set that isnotcheatable
Pointers versus Arithmetic in PRAMs

AbstractManipulation of pointers in shared data structures is an important communication mechanism used in many parallel algorithms. Indeed, many fundamental algorithms do essentially nothing else. Aparallel pointer machine(or PPM) is a parallel model having pointers as its principal data type. PPMs have been characterized as PRAMs obeying two restrictions—first, restricted arithmetic capabilities and, second, the CROW memory access restriction (concurrent read, owner write, a commonly occurring special case of CREW). We present results concerning the relative power of PPMs (and other arithmetically restricted PRAMs) versus CROW PRAMs having ordinary arithmetic capabilities. First, we prove lower bounds separating PPMs from CROW PRAMs. For example, any step-by-step simulation of ann-processor CROW PRAM by a PPM requires timeΩ(loglogn) per step. Second, we show that this lower bound is tight— we give such a step-by-step simulation using O(loglogn) time per step. As a corollary, we obtain sharply improved PPM algorithms for a variety of problems, including deterministic context-free language recognition
Relative to a Random Oracle, NP Is Not Small

AbstractResource-boundedmeasure as originated by Lutz is an extension of classical measure theory which provides a probabilistic means of describing the relative sizes of complexity classes. Lutz has proposed the hypothesis that NP does not havep-measure zero, meaning loosely that NP contains a non-negligible subset of exponential time. This hypothesis implies a strong separation of P from NP and is supported by a growing body of plausible consequences which are not known to follow from the weaker assertion P≠NP. It is shown in this paper that relative to a random oracle, NP does not havep-measure zero. The proof exploits the followingindependenceproperty of algorithmically random sequences: ifAis an algorithmically random sequence and a subsequenceA0is chosen by means of abounded Kolmogorov– Loveland place selection, then the sequenceA1of unselected bits is random relative toA0, i.e.,A0andA1are independent. A bounded Kolmogorov–Loveland place selection is a very general type of recursive selection rule which may be interpreted as the sequence of oracle queries of a time-bounded Turing machine, so the methods used may be applicable to other questions involving random oracles