pinecone/core-2020-05-10-deduplication huggingface dataset:
Self -Routing Superconcentrators

AbstractSuperconcentrators are switching systems that solve the generic problem of interconnecting clients and servers during sessions, in situations where either the clients or the servers are interchangeable (so that it does not matter which client is connected to which server). Previous constructions of superconcentrators have required an external agent to find the interconnections appropriate in each instance. We remedy this shortcoming by constructing superconcentrators that are “self -routing,” in the sense that they compute for themselves the required interconnections. Specifically, we show how to construct, for eachn, a systemSnwith the following properties: (1) The systemSnhasninputs,noutputs, andO(n) components, each of which is one of a fixed finite number of finite automata and is connected to a fixed finite number of other components through cables, each of which carries signals from a fixed finite alphabet. (2) When some of the inputs, and an equal number of outputs, are “marked” (by the presentation of a certain signal), then afterO(logn) steps (a time proportional to the “diameter” of the network) the system will establish a set of disjoint paths from the marked inputs to the marked outputs. The sizeO(n) is of course optimal for superconcentrators, as is the diameterO(logn) for superconcentrators of bounded degree
A Polynomial-Time Parsing Algorithm forK-Depth Languages

AbstractK-depth grammars extend context-free grammars allowingk⩾1 rewriting points for a single non-terminal at every step of a derivation. The family of languages generated byk-depth grammars is a proper extension of the family of context-free languages, while retaining many context-free properties, such as closure properties, a version of Chomsky–Schützenberger theorem, the existence of an accepting device (the multi-pushdown automaton). Here a polynomial-time parsing algorithm fork-depth languages is defined, and its correctness is proved
On the Structural Properties of the Set of Fixpoints for Nondeterministic Recursive Definitions

AbstractIn this paper, we investigate the structural properties of the set of fixpoints for the class of nondeterministic recursive definitions. Our study reveals close resemblance between the structural properties of the set of fixpoints and those of the set of prefixpoints, and it establishes some equality relationships between various fixpoints and their corresponding prefixpoints. Also observed are some nonequality relationships between various fixpoints and their corresponding postfixpoints
A Framework for Testing Safety and Effective Computability

AbstractThis paper presents a methodology for testing a logic program containing function symbols and built-in predicates forsafetyandeffective computability. Safety is the property that the set of answers for a given query is finite. A related issue is whether the evaluation strategy can effectively compute all answers and terminate. We consider these problems under the assumption that queries are evaluated using a fair bottom-up fixpoint computation. We also model the use of function symbols, to construct complex terms such as lists, and arithmetic operators, by considerating Datalog programs with infinite base relations over whichfiniteness constraintsandmonotonicity constraintsare imposed. One of the main results of this paper is a recursive algorithm,check–clique, to test the safety and effective computability of predicates in arbitrarily complex cliques in the predicate connection graph. This algorithm takes certain procedures as parameters, and its applicability can be strengthened by making these procedures more sophisticated. We specify the properties required of these procedures precisely, and present a formal proof of correctness for the algorithmcheck–clique. This work can be seen as providing a framework for testing safety and effective computability of recursive programs, in some ways analogous to thecapture rulesframework of Ullman. A second important contribution is a framework for analyzing programs that are produced by theMagic Setstransformation utilizingcheck–cliqueto analyze recursive cliques. The transformed program unfortunately often has a clique structure that combines several cliques of the original program. Given the complexity of algorithmcheck–clique, it is important to keep cliques as small as possible. We deal with this problem by considering cliques in an intermediate program, called theadorned program, produced by the Magic Sets transformation. The clique structure of the adorned program is similar to that of the original program, and by showing how to analyze the transformed program in terms of the cliques in the adorned program, we avoid the potentially expensive analysis of the cliques in the transformed program
Semantic Representations and Query Languages for Or-Sets

AbstractOr-sets were introduced by Imielinski, Naqvi, and Vadaparty for dealing with limited forms of disjunctive information in database queries. Independently, Rounds used a similar notion for representing disjunctive and conjunctive information in the context of situation theory. In this paper we formulate a query language with adequate expressive power for or-sets. Using the notion of normalization of or-sets, queries at the “structural” and “conceptual” levels are distinguished. Losslessness of normalization is established for a large class of queries. We obtain upper bounds for the cost of normalization. An approach related to that of Rounds is used to provide semantics for or-sets. We also treat or-sets in the context of partial information in databases
A Free Construction of Dynamic Terms

AbstractIn this paper we show that it is possible to extend in a natural way to the dynamic case some basic results of the classical approach to (static) data types. Within an appropriate framework of dynamic structures (calledd-oids), which play the same role as algebras in the static case, we define a language of dynamic terms, also enjoying the property of unique canonical representation; moreover, dynamic terms constitute a free structure whenever the static terms in the underlying static framework are so. As a main application of the above construction, we get a rather elegant kernel language for recursive definitions of dynamic derived operations, which parallels the well-known McCarthy's schema for a kernel applicative language. This kernel language can be seen also as a metalanguage for expressing the semantics of concrete (e.g., imperative or object-based) languages
Applications of Range Query Theory to Relational Data Base Join and Selection Operations

AbstractThis article applies range query theory to develop join algorithms that run inO(IlogdI+U) time, whereIandUare the sizes of the input and output anddis usually a small constant. One advantage of these algorithms is that they do not require the storage of an index, and they also use a working memory space guaranteed to be proportional to the size of the input. If the memory space is expanded toO(NPolylogN), our formalism also leads to the development of very fast indices supportingO(PolylogN) selection operations
Finite Languages for the Representation of Finite Graphs

AbstractWe introduce a new way of specifying graphs: through languages, i.e., sets of strings. The strings of a given (finite, prefix-free) language represent the vertices of the graph; whether or not there is an edge between the vertices represented by two strings is determined by the pair of symbols at the first position in these strings where they differ. With this new, “positional” or lexicographic, method, classical and well-understood ways of specifying languages can now be used to specify graphs, in a compact way; thus, (small) finite automata can be used to specify (large) graphs. Since (prefix-free) languages can be viewed as trees, our method generalizes the hierarchical specification of particular types of graphs such as cographs and VSP graphs. Our main results demonstrate an intrinsic relationship between the fundamental operations of language concatenation and graph substitution
Learning Sparse Multivariate Polynomials over a Field with Queries and Counterexamples

AbstractWe consider the problem of learning a polynomial over an arbitrary fieldFdefined on a set of boolean variables. We present the first provably effective algorithm for exactly identifying such polynomials using membership and equivalence queries. Our algorithm runs in time polynomial inn, the number of variables, andt, the number of nonzero terms appearing in the polynomial. The algorithm makes at mostnt+2 equivalence queries, and at most (nt+1)(t2+3t)/2 membership queries. Our algorithm is equally effective for learning a generalized type of polynomial defined on certain kinds of semilattices. We also present an extension of our algorithm for learning multilinear polynomials when the domain of each variable is the entire fieldF
Teaching a Smarter Learner

AbstractWe introduce a formal model of teaching in which the teacher is tailored to a particular learner, yet the teaching protocol is designed so that no collusion is possible. Not surprisingly, such a model remedies the nonintuitive aspects of other models in which the teacher must successfully teach any consistent learner. We prove that any class that can be exactly identified by a deterministic polynomial-time algorithm with access to a very rich set of example-based queries is teachable by a computationally unbounded teacher and a polynomial-time learner. In addition, we present other general results relating this model of teaching to various previous results. We also consider the problem of designing teacher/learner pairs in which both the teacher and learner are polynomial-time algorithms and describe teacher/learner pairs for the classes of 1-decision lists and Horn sentence
Asking Questions to Minimize Errors

AbstractA number of efficient learning algorithms achieve exact identification of an unknown function from some class using membership and equivalence queries. Using a standard transformation such algorithms can easily be converted to on-line learning algorithms that use membership queries. Under such a transformation the number of equivalence queries made by the query algorithm directly corresponds to the number of mistakes made by the on-line algorithm. In this paper we consider several of the natural classes known to be learnable in this setting, and investigate the minimum number of equivalence queries with accompanying counterexamples (or equivalently the minimum number of mistakes in the on-line model) that can be made by a learning algorithm that makes a polynomial number of membership queries and uses polynomial computation time. We are able both to reduce the number of equivalence queries used by the previous algorithms and often to prove matching lower bounds. As an example, consider the class of DNF formulas over n variables with at mostk=O(logn) terms. Previously, the algorithm of Blum and Rudich provided the best known upper bound of 2O(k)lognfor the minimum number of equivalence queries needed for exact identification. We greatly improve on this upper bound showing that exactlykcounterexamples are needed if the learner knowska priori and exactlyk+1 counterexamples are needed if the learner does not knowka priori. This exactly matches known lower bounds of Bshouty and Cleve. For many of our results we obtain a complete characterization of the trade-off between the number of membership and equivalence queries needed for exact identification. The classes we consider here are monotone DNF formulas, Horn sentences,O(logn)-term DNF formulas, read-ksat-jDNF formulas, read-once formulas over various bases, and deterministic finite automata
Temporal Interactions of Intervals in Distributed Systems

AbstractIn a space–time view of a distributed system, each point in space has its own time axis. This paper studies the interaction of intervals at different spatial points in a distributed system. We formalize the notion of what it means for one such interval to affect another such interval. Thus, this paper contributes to the quintessential field of the study of time. The results extend the 1972 work by Hamblin that demonstrated the interaction of time intervals which shared the same linear global time axis. The results also shed light on the nature of interprocess communication in distributed systems, an area which was pioneered by Lamport in 1986. The diverse suite of temporal relations between intervals included in our results provides much greater flexibility than do Lamport's relations to model interprocess interaction in a distributed system. The results are also useful in specifying global predicates and distributed synchronization conditions
Let Sleeping Files Lie: Pattern Matching in Z-Compressed Files

AbstractThe current explosion of stored information necessitates a new model of pattern matching, that ofcompressed matching. In this model one tries to find all occurrences of a pattern in a compressed text in time proportional to the compressed text size,i.e., without decompressing the text. The most effective general purpose compression algorithms areadaptive, in that the text represented by each compression symbol is determined dynamically by the data. As a result, the encoding of a substring depends on its location. Thus the same substring may “look different” every time it appears in the compressed text. In this paper we consider pattern matching without decompression in the UNIX Z-compression. This is a variant of the Lempel–Ziv adaptive compression scheme. Ifnis the length of thecompressedtext andmis the length of the pattern, our algorithms find the first pattern occurrence in timeO(n+m2) orO(nlogm+m). We also introduce a new criterion to measure compressed matching algorithms, that ofextra space. We show how to modify our algorithms to achieve a trade-off between the amount of extra space used and the algorithm's time complexity
Structural Average Case Complexity

AbstractLevin introduced an average-case complexity measure, based on a notion of “polynomial on average,” and defined “average-case polynomial-time many-one reducibility” among randomized decision problems. We generalize his notions of average-case complexity classes, Random-NP and Average-P. Ben-Davidet al. use the notation of 〈C, F〉 to denote the set of randomized decision problems (L, μ) such thatLis a set in C andμis a probability density function in F. This paper introduces Aver〈C, F〉 as the class of randomized decision problems (L, μ) such thatLis computed by a type-C machine onμ-average andμis a density function in F. These notations capture all known average-case complexity classes as, for example, Random-NP= 〈NP, P-comp〉 and Average-P=Aver〈P, ∗〉, where P-comp denotes the set of density functions whose distributions are computable in polynomial time, and ∗ denotes the set of all density functions. Mainly studied are polynomial-time reductions between randomized decision problems: many–one, deterministic Turing and nondeterministic Turing reductions and the average-case versions of them. Based on these reducibilities, structural properties of average-case complexity classes are discussed. We give average-case analogues of concepts in worst-case complexity theory; in particular, the polynomial time hierarchy and Turing self-reducibility, and we show that all known complete sets for Random-NP are Turing self-reducible. A new notion of “real polynomial-time computations” is introduced based on average polynomial-time computations for arbitrary distributions from a fixed set, and it is used to characterize the worst-case complexity classesΔpkandΣpkof the polynomial-time hierarchy
Onk-Dimensional Balanced Binary Trees

AbstractAn amortized analysis of the insertion and deletion algorithms ofk-dimensional balanced binary trees (kBB-trees) is performed. It is shown that the total rebalancing time for a mixed sequence ofminsertions and deletions in akBB-tree of sizenisO(k(m+n)). Based on 2BB-trees, a self-organizing tree, called aself-organizing balanced binary tree, is defined. It is shown that the average access time for an item stored in the tree is optimal to within a constant factor, while the worst-case access time is logarithmic. The amortized analysis ofkBB-trees leads to the result that the total update time for a mixed sequence ofmaccesses, insertions, and (restricted) deletions in a self-organizing balanced binary tree initially storingndata items isO(m+n
Exact Classification with Two-Layer Neural Nets

AbstractThis paper considers the classification properties of two-layer networks of McCulloch–Pitts units from a theoretical point of view. In particular we consider their ability to realise exactly, as opposed to approximate, bounded decision regions in R2. The main result shows that a two-layer network can realise exactly any finite union of bounded polyhedra in R2whose bounding lines lie in general position, except for some well-characterised exceptions. The exceptions are those unions whose boundaries contain a line which is “inconsistent,” as described in the text. Some of the results are valid for Rn,n⩾2, and the problem of generalising the main result to higher-dimensional situations is discussed
On Instance-Completeness for Database Query Languages involving Object Creation

AbstractIn 1978 Bancilhon and Paredaens introduced a notion of completeness for relational database languages on instance-level. Their criterion was subsequently calledBP-completeness. Since then, it was used frequently in the context of other database models. However, its application in the context of languages involving object creation appears to raise some serious problems. In this paper, we use the graph-oriented object database model GOOD as a framework to propose an alternative formulation of the BP-completeness criterion, adapted to the context of languages involving object creation
Learning Binary Perceptrons Perfectly Efficiently

AbstractThe majority rule algorithm for learning binary weights for a perceptron is analysed under the uniform distribution on inputs. It is shown that even though the algorithm is demonstrably inconsistent on random samples for very small sample sizes, it nevertheless exhibits a curious and abrupt asymptotic transition to consistency at moderate sample sizes. Particular consequences are that the algorithm PAC-learns majority functions in linear time from small samples and that, while the general variant of binary integer programming embodied here is NP-complete, almost all instances of the problem are tractable given a sufficient number of inequalities to be satisfie
The Intrinsic Complexity of Language Identification

AbstractA new investigation of the complexity of language identification is undertaken using the notion of reduction from recursion theory and complexity theory. The approach, referred to as the intrinsic complexity of language identification, employs notions of “weak” and “strong” reduction between learnable classes of languages. The intrinsic complexity of several classes is considered and the results agree with the intuitive difficulty of learning these classes. Several complete classes are shown for both the reductions and it is also established that the weak and strong reductions are distinct. An interesting result is that the self-referential class of Wiehagen in which the minimal element of every language is a grammar for the language and the class of pattern languages introduced by Angluin are equivalent in the strong sense. This study has been influenced by a similar treatment of function identification by Freivalds, Kinber, and Smith
Inclusion Problems in Parallel Learning and Games

AbstractIn a recent paper Kinber, Smith, Velauthapillai, and Wiehagen introduced a new notion of “parallel learning.” They call a setSof functions (m, n)-learnableif there is a learning machine which for any n-tuple of pairwise distinct functions fromSlearns at leastmfunctions correctly from examples of their behavior after seeing some finite amount of input. One of the basic open questions in this area is the “inclusion problem,” i.e., the question for whichm,n,h,k, every (m, n)-learnable class is also (h, k)-learnable. In this paper we develop a general approach to solve this problem. The idea is to associate with eachm,n,h,kin a uniform way a finite 2-player game such that the first player has a winning strategy in this game iff every (m, n)-learnable class is (h, k)-learnable. In this way we take the recursion theoretic disguise off the problem and isolate its combinatorial core. We also explicitly characterize the “strength” of each particular noninclusion by the complexity of an oracle which is needed to overcome it. It turns out that there are exactly three different types of noninclusions
Oracles and Queries That Are Sufficient for Exact Learning

AbstractWe show that the class of all circuits is exactly learnable in randomized expected polynomial time using weak subset and weak superset queries. This is a consequence of the following result which we consider to be of independent interest: circuits are exactly learnable in randomized expected polynomial time with equivalence queries and the aid of anNP-oracle. We also show that circuits are exactly learnable in deterministic polynomial time with equivalence queries and a ∑P3-oracle. The hypothesis class for the above learning algorithms is the class of circuits of larger—but polynomially related—size. Also, the algorithms can be adapted to learn the class of DNF formulas with hypothesis class consisting of depth-3 ∧-∨-∧ formulas (by the work of Angluin this is optimal in the sense that the hypothesis class cannot be reduced to DNF formulas, i.e., depth-2 ∨-∧ formulas). We also investigate the power of anNP-oracle in the context of learning withmembershipqueries. We show that there are deterministic learning algorithms that use membership queries and anNP-oracle to learn: monotone boolean functions in time polynomial in the DNF size and CNF size of the target formula; and the class ofO(logn)-DNF∩O(logn)-CNF formulas in time polynomial inn. We also show that, with anNP-oracle and membership queries, there is a randomized expected polynomial time algorithm that learns any class that is learnable from membership queries with unlimited computational power. Using similar techniques, we show the following both for membership and for equivalence queries (when the hypotheses allowed are precisely the concepts in the class); any class learnable with unbounded ?computational-power is learnable in deterministic polynomial time with a ∑:p5-oracle. Furthermore, we identify the combinatorial properties that completely determine learnability in this information-theoretic sense. Finally we point out a consequence of our result in structural complexity theory showing that if everyNPset has polynomial-size circuits then the polynomial hierarchy collapses to ZPPNP
Fat-Shattering and the Learnability of Real-Valued Functions

AbstractWe consider the problem of learning real-valued functions from random examples when the function values are corrupted with noise. With mild conditions on independent observation noise, we provide characterizations of the learnability of a real-valued function class in terms of a generalization of the Vapnik–Chervonenkis dimension, the fat-shattering function, introduced by Kearns and Schapire. We show that, given some restrictions on the noise, a function class is learnable in our model if an only if its fat-shattering function is finite. With different (also quite mild) restrictions, satisfied for example by guassion noise, we show that a function class is learnable from polynomially many examples if and only if its fat-shattering function grows polynomially. We prove analogous results in an agnostic setting, where there is no assumption of an underlying function class