OpenRaiser/Intern-Atlas huggingface dataset:
Oracle Complexity and Nontransitivity in Pattern Recognition
Venue: arXiv cs.CC 2000
Year: 2000

Different mathematical models of recognition processes are known. In the present paper we consider a pattern recognition algorithm as an oracle computation on a Turing machine. Such point of view seems to be useful in pattern recognition as well as in recursion theory. Use of recursion theory in pattern recognition shows connection between a recognition algorithm comparison problem and complexity problems of oracle computation. That is because in many cases we can take into account only the number of sign computations or in other words volume of oracle information needed. Therefore, the problem of recognition algorithm preference can be formulated as a complexity optimization problem of oracle computation. Furthermore, introducing a certain "natural" preference relation on a set of recognizing algorithms, we discover it to be nontransitive. This relates to the well known nontransitivity paradox in probability theory. Keywords: Pattern Recognition, Recursion Theory, Nontransitivity, Preference Relation
Reduction of Intermediate Alphabets in Finite-State Transducer Cascades
Venue: arXiv cs.CL 2000
Year: 2000

This article describes an algorithm for reducing the intermediate alphabets in cascades of finite-state transducers (FSTs). Although the method modifies the component FSTs, there is no change in the overall relation described by the whole cascade. No additional information or special algorithm, that could decelerate the processing of input, is required at runtime. Two examples from Natural Language Processing are used to illustrate the effect of the algorithm on the sizes of the FSTs and their alphabets. With some FSTs the number of arcs and symbols shrank considerably.
Computational Geometry Column 40
Venue: arXiv cs.CG 2000
Year: 2000

It has recently been established by Below, De Loera, and Richter-Gebert that finding a minimum size (or even just a small) triangulation of a convex polyhedron is NP-complete. Their 3SAT-reduction proof is discussed.
Designing Proxies for Stock Market Indices is Computationally Hard
Venue: arXiv cs.CE 2000
Year: 2000

In this paper, we study the problem of designing proxies (or portfolios) for various stock market indices based on historical data. We use four different methods for computing market indices, all of which are formulas used in actual stock market analysis. For each index, we consider three criteria for designing the proxy: the proxy must either track the market index, outperform the market index, or perform within a margin of error of the index while maintaining a low volatility. In eleven of the twelve cases (all combinations of four indices with three criteria except the problem of sacrificing return for less volatility using the price-relative index) we show that the problem is NP-hard, and hence most likely intractable.
Optimal Buy-and-Hold Strategies for Financial Markets with Bounded Daily Returns
Venue: arXiv cs.CE 2000
Year: 2000

In the context of investment analysis, we formulate an abstract online computing problem called a planning game and develop general tools for solving such a game. We then use the tools to investigate a practical buy-and-hold trading problem faced by long-term investors in stocks. We obtain the unique optimal static online algorithm for the problem and determine its exact competitive ratio. We also compare this algorithm with the popular dollar averaging strategy using actual market data.
On-the-fly Query-Based Debugging with Examples
Venue: arXiv cs.SE 2000
Year: 2000

Program errors are hard to find because of the cause-effect gap between the time when an error occurs and the time when the error becomes apparent to the programmer. Although debugging techniques such as conditional and data breakpoints help to find error causes in simple cases, they fail to effectively bridge the cause-effect gap in many situations. Query-based debuggers offer programmers an effective tool that provides instant error alert by continuously checking inter-object relationships while the debugged program is running. To enable the query-based debugger in the middle of program execution in a portable way, we propose efficient Java class file instrumentation and discuss alternative techniques. Although the on-the-fly debugger has a higher overhead than a dynamic query-based debugger, it offers additional interactive power and flexibility while maintaining complete portability. To speed up dynamic query evaluation, our debugger implemented in portable Java uses a combination of program instrumentation, load-time code generation, query optimization, and incremental reevaluation. This paper discusses on-the-fly debugging and demonstrates the query-based debugger application for debugging Java gas tank applet as well as SPECjvm98 suite applications.
Provably Fast and Accurate Recovery of Evolutionary Trees through Harmonic Greedy Triplets
Venue: arXiv cs.DS 2000
Year: 2000

We give a greedy learning algorithm for reconstructing an evolutionary tree based on a certain harmonic average on triplets of terminal taxa. After the pairwise distances between terminal taxa are estimated from sequence data, the algorithm runs in O(n^2) time using O(n) work space, where n is the number of terminal taxa. These time and space complexities are optimal in the sense that the size of an input distance matrix is n^2 and the size of an output tree is n. Moreover, in the Jukes-Cantor model of evolution, the algorithm recovers the correct tree topology with high probability using sample sequences of length polynomial in (1) n, (2) the logarithm of the error probability, and (3) the inverses of two small parameters.
A Complete Characterization of Complete Intersection-Type Theories
Venue: arXiv cs.LO 2000
Year: 2000

We characterize those intersection-type theories which yield complete intersection-type assignment systems for lambda-calculi, with respect to the three canonical set-theoretical semantics for intersection-types: the inference semantics, the simple semantics and the F-semantics. These semantics arise by taking as interpretation of types subsets of applicative structures, as interpretation of the intersection constructor set-theoretic inclusion, and by taking the interpretation of the arrow constructor a' la Scott, with respect to either any possible functionality set, or the largest one, or the least one. These results strengthen and generalize significantly all earlier results in the literature, to our knowledge, in at least three respects. First of all the inference semantics had not been considered before. Secondly, the characterizations are all given just in terms of simple closure conditions on the preorder relation on the types, rather than on the typing judgments themselves. The task of checking the condition is made therefore considerably more tractable. Lastly, we do not restrict attention just to lambda-models, but to arbitrary applicative structures which admit an interpretation function. Thus we allow also for the treatment of models of restricted lambda-calculi. Nevertheless the characterizations we give can be tailored just to the case of lambda-models.
Do All Fragments Count?
Venue: arXiv cs.CL 2000
Year: 2000

We aim at finding the minimal set of fragments which achieves maximal parse accuracy in Data Oriented Parsing. Experiments with the Penn Wall Street Journal treebank show that counts of almost arbitrary fragments within parse trees are important, leading to improved parse accuracy over previous models tested on this treebank. We isolate a number of dependency relations which previous models neglect but which contribute to higher parse accuracy.
Scaling Up Inductive Logic Programming by Learning from Interpretations
Venue: arXiv cs.LG 2000
Year: 2000

When comparing inductive logic programming (ILP) and attribute-value learning techniques, there is a trade-off between expressive power and efficiency. Inductive logic programming techniques are typically more expressive but also less efficient. Therefore, the data sets handled by current inductive logic programming systems are small according to general standards within the data mining community. The main source of inefficiency lies in the assumption that several examples may be related to each other, so they cannot be handled independently. Within the learning from interpretations framework for inductive logic programming this assumption is unnecessary, which allows to scale up existing ILP algorithms. In this paper we explain this learning setting in the context of relational databases. We relate the setting to propositional data mining and to the classical ILP setting, and show that learning from interpretations corresponds to learning from multiple relations and thus extends the expressiveness of propositional learning, while maintaining its efficiency to a large extent (which is not the case in the classical ILP setting). As a case study, we present two alternative implementations of the ILP system Tilde (Top-down Induction of Logical DEcision trees): Tilde-classic, which loads all data in main memory, and Tilde-LDS, which loads the examples one by one. We experimentally compare the implementations, showing Tilde-LDS can handle large data sets (in the order of 100,000 examples or 100 MB) and indeed scales up linearly in the number of examples.
Available Stabilizing Heaps
Venue: arXiv cs.DC 2000
Year: 2000

This paper describes a heap construction that supports insert and delete operations in arbitrary (possibly illegitimate) states. After any sequence of at most O(m) heap operations, the heap state is guarantee to be legitimate, where m is the initial number of items in the heap. The response from each operation is consistent with its effect on the data structure, even for illegitimate states. The time complexity of each operation is O(lg K) where K is the capacity of the data structure; when the heap's state is legitimate the time complexity is O(lg n) for n equal to the number items in the heap.
Random Shuffling to Reduce Disorder in Adaptive Sorting Scheme
Venue: arXiv cs.DS 2000
Year: 2000

In this paper we present a random shuffling scheme to apply with adaptive sorting algorithms. Adaptive sorting algorithms utilize the presortedness present in a given sequence. We have probabilistically increased the amount of presortedness present in a sequence by using a random shuffling technique that requires little computation. Theoretical analysis suggests that the proposed scheme can improve the performance of adaptive sorting. Experimental results show that it significantly reduces the amount of disorder present in a given sequence and improves the execution time of adaptive sorting algorithm as well.
A Virtual Java Simulation Lab for Computer Science Students
Venue: arXiv cs.OH 2000
Year: 2000

The VJ-Lab is a project oriented to improve the students learning process of Computer Science degree at the National University of La Plata. The VJ-Lab is a Web application with Java based simulations. Java can be used to provide simulation environments with simple pictorial interfaces that can help students to understand the subject. There are many fields in which it is difficult to give students a feel for the subject that they are learning. Computer based simulations offer a fun and effective way to enable students to learn by doing. Both, practicing skills and applying knowledge are both allowed in simulated worlds. We will focus on the VJ-Lab project overview, the work in progress and some Java based simulations running. They imitate the behavior of data network protocol and data structure algorithms. These applets are produced by the students of the 'Software Development Laboratory' course.
Towards Robust Quantum Computation
Venue: arXiv cs.CC 2000
Year: 2000

Quantum computation is a subject of much theoretical promise, but has not been realized in large scale, despite the discovery of fault-tolerant procedures to overcome decoherence. Part of the reason is that the theoretically modest requirements still present daunting experimental challenges. The goal of this Dissertation is to reduce various resources required for robust quantum computation, focusing on quantum error correcting codes and solution NMR quantum computation. A variety of techniques have been developed, including high rate quantum codes for amplitude damping, relaxed criteria for quantum error correction, systematic construction of fault-tolerant gates, recipes for quantum process tomography, techniques in bulk thermal state computation, and efficient decoupling techniques to implement selective coupled logic gates. A detailed experimental study of a quantum error correcting code in NMR is also presented. The Dissertation clarifies and extends results previously reported in quant-ph/9610043, quant-ph/9704002, quant-ph/9811068, quant-ph/9904100, quant-ph/9906112, quant-ph/0002039. Additionally, a procedure for quantum process tomography using maximally entangled states, and a review on NMR quantum computation are included.
A Note on Power-Laws of Internet Topology
Venue: arXiv cs.NI 2000
Year: 2000

The three Power-Laws proposed by Faloutsos et al(1999) are important discoveries among many recent works on finding hidden rules in the seemingly chaotic Internet topology. In this note, we want to point out that the first two laws discovered by Faloutsos et al(1999, hereafter, {\it Faloutsos' Power Laws}) are in fact equivalent. That is, as long as any one of them is true, the other can be derived from it, and {\it vice versa}. Although these two laws are equivalent, they provide different ways to measure the exponents of their corresponding power law relations. We also show that these two measures will give equivalent results, but with different error bars. We argue that for nodes of not very large out-degree($\leq 32$ in our simulation), the first Faloutsos' Power Law is superior to the second one in giving a better estimate of the exponent, while for nodes of very large out-degree($> 32$) the power law relation may not be present, at least for the relation between the frequency of out-degree and node out-degree.
A Benchmark for Image Retrieval using Distributed Systems over the Internet: BIRDS-I
Venue: arXiv cs.IR 2000
Year: 2000

The performance of CBIR algorithms is usually measured on an isolated workstation. In a real-world environment the algorithms would only constitute a minor component among the many interacting components. The Internet dramati-cally changes many of the usual assumptions about measuring CBIR performance. Any CBIR benchmark should be designed from a networked systems standpoint. These benchmarks typically introduce communication overhead because the real systems they model are distributed applications. We present our implementation of a client/server benchmark called BIRDS-I to measure image retrieval performance over the Internet. It has been designed with the trend toward the use of small personalized wireless systems in mind. Web-based CBIR implies the use of heteroge-neous image sets, imposing certain constraints on how the images are organized and the type of performance metrics applicable. BIRDS-I only requires controlled human intervention for the compilation of the image collection and none for the generation of ground truth in the measurement of retrieval accuracy. Benchmark image collections need to be evolved incrementally toward the storage of millions of images and that scaleup can only be achieved through the use of computer-aided compilation. Finally, our scoring metric introduces a tightly optimized image-ranking window.
Set-Theoretic Completeness for Epistemic and Conditional Logic
Venue: arXiv cs.AI 2000
Year: 2000

The standard approach to logic in the literature in philosophy and mathematics, which has also been adopted in computer science, is to define a language (the syntax), an appropriate class of models together with an interpretation of formulas in the language (the semantics), a collection of axioms and rules of inference characterizing reasoning (the proof theory), and then relate the proof theory to the semantics via soundness and completeness results. Here we consider an approach that is more common in the economics literature, which works purely at the semantic, set-theoretic level. We provide set-theoretic completeness results for a number of epistemic and conditional logics, and contrast the expressive power of the syntactic and set-theoretic approaches
Expoiting Syntactic Structure for Language Modeling
Venue: arXiv cs.CL 2000
Year: 2000

The paper presents a language model that develops syntactic structure and uses it to extract meaningful information from the word history, thus enabling the use of long distance dependencies. The model assigns probability to every joint sequence of words--binary-parse-structure with headword annotation and operates in a left-to-right manner --- therefore usable for automatic speech recognition. The model, its probabilistic parameterization, and a set of experiments meant to evaluate its predictive power are presented; an improvement over standard trigram modeling is achieved.
Linear-Time Approximation Algorithms for Computing Numerical Summation with Provably Small Errors
Venue: arXiv cs.DS 2000
Year: 2000

Given a multiset $X=\{x_1,..., x_n\}$ of real numbers, the {\it floating-point set summation} problem asks for $S_n=x_1+...+x_n$. Let $E^*_n$ denote the minimum worst-case error over all possible orderings of evaluating $S_n$. We prove that if $X$ has both positive and negative numbers, it is NP-hard to compute $S_n$ with the worst-case error equal to $E^*_n$. We then give the first known polynomial-time approximation algorithm that has a provably small error for arbitrary $X$. Our algorithm incurs a worst-case error at most $2(\mix)E^*_n$.\footnote{All logarithms $\log$ in this paper are base 2.} After $X$ is sorted, it runs in O(n) time. For the case where $X$ is either all positive or all negative, we give another approximation algorithm with a worst-case error at most $\lceil\log\log n\rceil E^*_n$. Even for unsorted $X$, this algorithm runs in O(n) time. Previously, the best linear-time approximation algorithm had a worst-case error at most $\lceil\log n\rceil E^*_n$, while $E^*_n$ was known to be attainable in $O(n \log n)$ time using Huffman coding.
Numeration systems on a regular language: Arithmetic operations, Recognizability and Formal power series
Venue: arXiv cs.CC 2000
Year: 2000

Generalizations of numeration systems in which N is recognizable by a finite automaton are obtained by describing a lexicographically ordered infinite regular language L over a finite alphabet A. For these systems, we obtain a characterization of recognizable sets of integers in terms of rational formal series. We also show that, if the complexity of L is Theta (n^q) (resp. if L is the complement of a polynomial language), then multiplication by an integer k preserves recognizability only if k=t^{q+1} (resp. if k is not a power of the cardinality of A) for some integer t. Finally, we obtain sufficient conditions for the notions of recognizability and U-recognizability to be equivalent, where U is some positional numeration system related to a sequence of integers.
Seeing the Forest in the Tree: Applying VRML to Mathematical Problems in Number Theory
Venue: arXiv cs.MS 2000
Year: 2000

We show how VRML (Virtual Reality Modeling Language) can provide potentially powerful insight into the 3x + 1 problem via the introduction of a unique geometrical object, called the 'G-cell', akin to a fractal generator. We present an example of a VRML world developed programmatically with the G-cell. The role of VRML as a tool for furthering the understanding the 3x+1 problem is potentially significant for several reasons: a) VRML permits the observer to zoom into the geometric structure at all scales (up to limitations of the computing platform). b) VRML enables rotation to alter comparative visual perspective (similar to Tukey's data-spinning concept). c) VRML facilitates the demonstration of interesting tree features between collaborators on the internet who might otherwise have difficulty conveying their ideas unambiguously. d) VRML promises to reveal any dimensional dependencies among 3x+1 sequences.
Using Modes to Ensure Subject Reduction for Typed Logic Programs with Subtyping
Venue: arXiv cs.LO 2001
Year: 2001

We consider a general prescriptive type system with parametric polymorphism and subtyping for logic programs. The property of subject reduction expresses the consistency of the type system w.r.t. the execution model: if a program is "well-typed", then all derivations starting in a "well-typed" goal are again "well-typed". It is well-established that without subtyping, this property is readily obtained for logic programs w.r.t. their standard (untyped) execution model. Here we give syntactic conditions that ensure subject reduction also in the presence of general subtyping relations between type constructors. The idea is to consider logic programs with a fixed dataflow, given by modes.
Optimal Moebius Transformations for Information Visualization and Meshing
Venue: arXiv cs.CG 2001
Year: 2001

We give linear-time quasiconvex programming algorithms for finding a Moebius transformation of a set of spheres in a unit ball or on the surface of a unit sphere that maximizes the minimum size of a transformed sphere. We can also use similar methods to maximize the minimum distance among a set of pairs of input points. We apply these results to vertex separation and symmetry display in spherical graph drawing, viewpoint selection in hyperbolic browsing, element size control in conformal structured mesh generation, and brain flat mapping.
Semantics and Termination of Simply-Moded Logic Programs with Dynamic Scheduling
Venue: arXiv cs.LO 2001
Year: 2001

In logic programming, dynamic scheduling refers to a situation where the selection of the atom in each resolution (computation) step is determined at runtime, as opposed to a fixed selection rule such as the left-to-right one of Prolog. This has applications e.g. in parallel programming. A mechanism to control dynamic scheduling is provided in existing languages in the form of delay declarations. Input-consuming derivations were introduced to describe dynamic scheduling while abstracting from the technical details. In this paper, we first formalise the relationship between delay declarations and input-consuming derivations, showing in many cases a one-to-one correspondence. Then, we define a model-theoretic semantics for input-consuming derivations of simply-moded programs. Finally, for this class of programs, we provide a necessary and sufficient criterion for termination.
The Guidebook, the Friend, and the Room: Visitor Experience in a Historic House
Venue: arXiv cs.HC 2001
Year: 2001

In this paper, we describe an electronic guidebook prototype and report on a study of its use in a historic house. Supported by mechanisms in the guidebook, visitors constructed experiences that had a high degree of interaction with three entities: the guidebook, their companions, and the house and its contents. For example, we found that most visitors played audio descriptions played through speakers (rather than using headphones or reading textual descriptions) to facilitate communication with their companions.