ppxscal/embedding_network huggingface dataset:
Using WordNet to disambiguate word senses for text retrieval
Authors: Ellen M. Voorhees
Venue: Proceedings of the 16th annual international ACM SIGIR conference on Research and development in information retrieval (1993)

This paper describes an automatic indexing procedure that uses the &ldquo;IS-A&rdquo; relations contained within WordNet and the set of nouns contained in a text to select a sense for each plysemous noun in the text. The result of the indexing procedure is a vector in which some of the terms represent word senses instead of word stems. Retrieval experiments comparing the effectivenss of these sense-based vectors vs. stem-based vectors show the stem-based vectors to be superior overall, although the sense-based vectors do improve the performance of some queries. The overall degradation is due in large part to the difficulty of disambiguating senses in short query statements. An analysis of these results suggests two conclusions: the IS-A links define a generalization/specialization hierarchy that is not sufficient to reliably select the correct sense of a noun from the set of fine sense distinctions in WordNet; and missing correct matches because of incorrect sense resolution has a much more deleterious effect on retrieval performance than does making spurious matches.
Model-based object recognition in dense-range images&mdash;a review
Authors: Farshid Arman, J. K. Aggarwal
Venue: ACM Computing Surveys (CSUR) (1993)

The goal in computer vision systems is to analyze data collected from the environment and derive an interpretation to complete a specified task. Vision system tasks may be divided into data acquisition, low-level processing, representation, model construction, and matching subtasks. This paper presents a comprehensive survey of model-based vision systems using dense-range images. A comprehensive survey of the recent publications in each subtask pertaining to dense-range image object recognition is presented.
The impact of operating system structure on memory system performance
Authors: J. Bradley Chen, Brian N. Bershad
Venue: Proceedings of the fourteenth ACM symposium on Operating systems principles (1994)

In this paper we evaluate the memory system behavior of two distinctly different implementations of the UNIX operating system: DEC's Ultrix, a monolithic system, and Mach 3.0 with CMU's UNIX server, a microkernel-based system. In our evaluation we use combined system and user memory reference traces of thirteen industry-standard workloads. We show that the microkernel-based system executes substantially more non-idle system instructions for an equivalent workload than the monolithic system. Furthermore, the average instruction for programs running on Mach has a higher cost, in terms of memory cycles per instruction, than on Ultrix. In the context of our traces, we explore a number of popular assertions about the memory system behavior of modern operating systems, paying special attention to the effect that Mach's microkernel architecture has on system performance. Our results indicate that many, but not all of the assertions are true, and that a few, while true, have only negligible impact on real system performance.
Mechanisms for generic process support
Authors: Robert Balzer, K. Narayanaswamy
Venue: Proceedings of the 1st ACM SIGSOFT symposium on Foundations of software engineering (1993)

As more and more programming environments incorporate explicit process descriptions, generic process capabilities will become crucial to the convenient instantiation and maintenance of process description. However, partly because process modeling languages have followed the example of programming languages in general, they are surprisingly weak in supporting generic process descriptions.We propose mechanisms whereby generic process capability can be added to any process formalism. The generic portions of the process description can then be refined through instantiation. We define a system architecture in which a generic process description can be refined gradually during its enactment. Such capabilities will be crucial to incorporating explicit process descriptions into the program environments of the future.
HDM&mdash;a model-based approach to hypertext application design
Authors: Franca Garzotto, Paolo Paolini, Daniel Schwabe
Venue: ACM Transactions on Information Systems (TOIS) (1993)

Hypertext development should benefit from a systematic, structured development, especially in the case of large and complex applications. A structured approach to hypertext development suggests the notion of authoring-in-the-large. Authoring-in-the-large allows the description of overall classes of information elements and navigational structures of complex applications without much concern with implementation details, and in a system-independent manner. The paper presents HDM (Hypertext Design Model), a first step towards defining a general purpose model for authoring-in-the-large. Some of the most innovative features of HDM are: the notion of perspective; the identification of different categories of links (structural links, application links, and perspective links) with different representational roles; the distinction between hyperbase and access structures; and the possibility of easily integrating the structure of a hypertext application with its browsing semantics. HDM can be used in different manners: as a modeling device or as an implementation device. As a modeling device, it supports producing high level specifications of existing or to-be-developed applications. As an implementation device, it is the basis for designing tools that directly support application development. One of the central advantages of HDM in the design and practical construction of hypertext applications is that the definition of a significant number of links can be derived automatically from a conceptual-design level description. Examples of usage of HDM are also included.
Specified precision polynomial root isolation is in NC
Authors: C. Andrew Neff
Venue: Journal of Computer and System Sciences (1994)

Given a polynomial p(z) of degree n with integer coefficients, whose absolute values are bounded above by 2^m, and a specified integer @m, we show that the problem of determining all roots of p with error less than 2^-^@m is in the parallel complexity class NC. To do this, we construct an algorithm which runs on at most D(n + m + @m)^f processors in at most C log^e(n + m - @m) parallel steps, where the constants C, D, e, f are given in terms of the corresponding processor and time bounds for the computation of certain elementary polynomial and matrix operations. In fact, one can easily see that the time complexity is O(log^3(n + m + @m)). Thus, the algorithm presented here extends the algorithm of Ben-Or, Feig, Kozen, and Tiwari by removing the severe restriction that all the roots of p(z) be real.
Creating well formed class inheritance schemes in C++
Authors: Frederic H. Wild
Venue: ACM SIGPLAN OOPS Messenger (1993)

How do we know when we have a well formed inheritance scheme? What are the criteria that we can use to judge? These are important questions that we must consider. For most people, inheritance is a rather new design discipline, and its implementation in C++ allows ample opportunity to create both good and bad examples of its use. In this paper we explore how the design criteria for inheritance is both similar to, and different from, conventional design considerations. We also discuss a set of anomalies that should be removed from proposed C++ inheritance schemes [1], which can be used to judge whether inheritance constructs are well formed or not.
On the mechanical derivation of loop invariants
Authors: Ritu Chadha, David A. Plaisted
Venue: Journal of Symbolic Computation (1993)

We describe an iterative algorithm for mechanically deriving loop invariants for the purpose of proving the partial correctness of programs. The algorithm is based on resolution and a novel unskolemization technique for deriving logical consequences of first-order formulas. Our method is complete in the sense that if a loop invariant exists for a loop in a given first-order language relative to a given finite set of first-order axioms, then the algorithm produces a loop invariant for that loop which can be used for proving the partial correctness of the program. Existing techniques in the literature are not complete.
A RISC processor architecture with a versatile stack system
Authors: Claus Aßmann
Venue: ACM SIGARCH Computer Architecture News (1993)

Modern RISC processors mainly differ w.r.t, the organization of their register files. There are currently three different approaches: a flat register file (e.g., MIPS), fixed-size register windows (SPARC), or a stack-like organization (AM29K). This paper describes a processor architecture with a new stack system, which is tailored to the needs of executing functional languages. In order to support a fast subroutine call mechanism and efficient parameter passing, our architecture uses a system of four stacks, of which two are interchangeable.A simulation of this processor architecture shows that a selection of functional benchmark programs can be executed with less machine cycles than equivalent code-optimized C programs on a SPARC or MIPS processor.
A logical semantics for object-oriented databases
Authors: José Meseguer, Xiaolei Qian
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Although the mathematical foundations of relational databases are very well established, the state of affairs for object-oriented databases is much less satisfactory. We propose a semantic foundation for object-oriented databases based on a simple logic of change called rewriting logic, and a language called MaudeLog that is based on that logic. Some key advantages of our approach include its logical nature, its simplicity without any need for higher-order features, the fact that dynamic aspects are directly addressed, the rigorous integration of user-definable algebraic data types within the framework, the existence of initial models, and the integration of query, update, and programming aspects within a single declarative language.
Algorithm 723: Fresnel integrals
Authors: W. van Snyder
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

An implementation of approximations for Fresnel integrals and associated functions is described. The approximations were originally developed by W. J. Cody, but a Fortran implementation using them has not previously been published.
A &ldquo;linear logic&rdquo; Quicksort
Authors: Henry G. Baker
Venue: ACM SIGPLAN Notices (1994)

The linear style of programming inspired by linear logic has been proposed to reduce garbage collection and synchronization costs in serial and parallel systems. We programmed Quicksort for both lists and arrays in a "linear" fragment of Lisp to estimate the performance impact of linearity on a serial machine. Even though Quicksort is well-tuned for current non-linear architectures, we find that linearity extracts no real penalty. Our "linear" list Quicksort is as fast as any non-linear list Quicksort, and our "linear" vector Quicksort is only 3.5% slower than a non-linear vector Quicksort. The linear style is moderately pleasant, and the redundancy of linearity checking can aid in finding bugs.
Hilbert Series of Group Representations and Gr&ouml;bner Bases for Generic Modules
Authors: Shmuel Onn
Venue: Journal of Algebraic Combinatorics: An International Journal (1994)

Each matrix representation \pi\!: G \longrightarrow {\rm GL}_n({\cal K})of a finite Group G over a field {\cal K} induces an action of G on the module {\cal A}^n over the polynomial algebra {\cal A}={\cal K}[x_1, \ldots , x_n] The graded {\cal A}\hbox{-submodule} M(&Pi;) of {\cal A}^n generated by the orbit of (x_1, \ldots ,x_n) is studied. A decomposition of M(&Pi;) into generic modules is given. Relations between the numerical invariants of &Pi; and those of M(&Pi;), the latter being efficiently computable by Gr&ouml;bner bases methods, are examined. It is shown that if &Pi; is multiplicity-free, then the dimensions of the irreducible constituents of &Pi; can be read off from the Hilbert series of M(Pi;). It is proved that determinantal relations form Gr&ouml;bner bases for the syzygies on generic matrices with respect to any lexicographic order. Gr&ouml;bner bases for generic modules are also constructed, and their Hilbert series are derived. Consequently, the Hilbert series of M(Pi;) is obtained for an arbitrary representation.
Verifiable secret sharing for monotone access structures
Authors: Thomas Beth, Hans-Joachim Knobloch, Marcus Otten
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

Several verifiable secret sharing schemes for threshold schemes based on polynomial interpolation have been presented in the literature. Simmons and others introduced secret sharing (also called shared control) schemes based on finite geometries, which allow istributing a secret according to any monotone access structure.In this paper we present a verifiable secret sharing scheme for a class of these geometry-based secret sharing schemes, which thus provides verifiable sharing of secrets according to general monotone access structures.Our scheme relies on the homomorphic properties of the discrete exponentiation and therefore on the cryptographic security of the discrete logarithm. The version based on Simmons' scheme is non-interactive.
New bounds for lower envelopes in three dimensions, with applications to visibility in terrains
Authors: Dan Halperin, Micha Sharir
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

We consider the problem of bounding the complexity of the lower envelope of n surface patches in 3-space, all algebraic of constant maximum degree, and bounded by algebraic arcs of constant maximum degree, with the additional property that the interiors of any triple of these surfaces intersect in at most two points. We show that the number of vertices on the lower envelope of n such surface patches is On2&dot;2clog n for some constant c depending on the shape and degree of the surface patches. We apply this result to obtain an upper bound on the combinatorial complexity of the &ldquo;lower envelope&rdquo; of the space of all rays in 3-space that lie above a given polyhedral terrain K with n edges. This envelope consists of all rays that touch the terrain (but otherwise lie above it). We show that the combinatorial complexity of this ray-envelope is On2&dot;2clog n for some constant c; in particular, there are at most that many rays that pass above the terrain and touch it in 4 edges. This bound, combined with the analysis of de Berg et al. [2], gives an upper bound (which is almost tight in the worst case) on the number of topologically-different orthographic views of such a terrain.
On the feasibility of checking temporal integrity constraints
Authors: Jan Chomicki, Damian Niwiński
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

We analyze the computational feasibility of checking temporal integrity constraints formulated in some sublanguages of first-order temporal logic. Our results illustrate the impact of the quantification on the complexity of this problem. The presence of a single quantifier in the scope of a temporal operator makes the problem undecidable. On the other hand, if no quantifiers are in the scope of a temporal operator and all the quantifiers are universal, temporal integrity checking can be done in exponential time.
SIGCHI annual report, 1992&ndash;1993
Authors: Austin Henderson
Venue: ACM SIGCHI Bulletin (1993)

SIGCHI has had, as usual, a busy year. The membership has continued to grow slowly despite the economic climate, something we are very pleased with. At the close it has dropped slightly, something to be watched. The volunteer structure has been adequate to the programs we have undertaken; those involved are very enthusiastic. Debate on the future of the organization is continual, reflecting healthy involvement and concern. Our relations with other SIGs, the ACM volunteer structure, and the ACM professional staff has been very rewarding. In short, while not without difficulties and challenges, SIGCHI is a thriving organization.
The European Space Software Development Environment Reference Facility Project: a status report
Authors: John Favaro, Yves Coene, Marco Casucci
Venue: ACM SIGSOFT Software Engineering Notes (1994)

The ESSDE Reference Facility Project, whose goal is to provide a uniform, open environment for software development at the European Space Agency (ESA), has just completed the architectural design phase. A software engineering environment based upon the Portable Common Tool Environment (PCTE) interfaces has been specified, including a complete data model supporting all activities and products in the ESA standard software development life cycle. Several issues of much current interest have been addressed including scalability, configurability and the integration of commercial tools into an existing framework.
Research-guided design of multimedia research tools
Authors: Robert J. Beichner
Venue: ACM SIGGRAPH Computer Graphics (1994)

Since this issue of the newsletter features both multimedia designers and research-oriented users, I thought it would be interesting to merge the two viewpoints and describe my approach to the design of some of the multimedia software I use in my research. The main point of this article is to describe how the findings of prior research can be used to guide the design of software which itself is to be used for additional research. The beginning of the discussion will center around the development of a C program called "VideoGraph." The name furnishes a hint as to what the program does---it provides introductory physics students with a tool for graphically analyzing video sequences. A second package was designed to provide a multimedia editing environment for use by middle school students. Although these two projects sound very different, the software for both shares the same purpose---it gives students multimedia tools to help them learn science topics while minimizing the distraction of the software itself. The research investigated the educational impact of the software.
Negation and minimality in non-horn databases
Authors: Marco Schaerf
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

Two main approaches have been followed in the literature to give a semantics to non-Horn databases. The first one is based on considering the set of rules composing the programs as inference rules and interpreting the negation in the body as failure to prove. The other approach is based on the so-called closed-world assumption and its objective is to define a stronger notion of consequence from a theory than the classical one, where, very roughly, negative information can be inferred whenever its positive counterpart cannot be deduced from the theory. In this work we generalize the semantics for negation in logic programs, putting together the constructive nature of the rule-based deductive databases with the syntax-independence of the closed-world reasoning rules. These generalized semantics are shown to be a well-motivated and well-founded alternative to closed-world assumptions since they enjoy nice semantic and computational properties.
An approach toward mechanization of acquiring reusable software components
Authors: Zongming Fei, Jian Lu
Venue: ACM SIGPLAN Notices (1993)

This paper gives a method for acquiring reusable software components automatically. Two categories of resources are distinguished, i.e., reusable patterns and reusable building blocks. It employs explanation--based learning method to analyse the concrete software design and generate its structural description, which, combined with semantic constraints, constitutes the reusable patterns. In order to obtain reusable building blocks, it applies both deduction and induction to construct the functional description of code fragment hierarchically, which , associated with code , is truly reusable in some sense. The ability of the system is enhanced with the acquisition of these reusable components and the scope of solvable problems is enlarged by employing them.
Fine grained object protection in UNIX
Authors: Marie Rose Low, Bruce Christianson
Venue: ACM SIGOPS Operating Systems Review (1993)

In this document we describe and discuss a solution, called UNIX Access Table Protection (UATP), to the problem of providing a secure environment for persistent object types with fine grained protection on a UNIX system. UATP requires no modifications to the UNIX kernel. User's on UNIX have discretionary access control over their directories and files. By using these controls in a particular way, this paper shows a way in which a hierarchy of protection domains can be set up to enable object methods and type instances to be managed securely and to be protected from unauthorised use. The document also describes how a particular object type, a UATP-kernel, which executes in these protection domains (in the same way as all other objects) can be used to provide fine grained protection for all other objects which are installed and running in the manner described here.
A checkable interface language for pointer-based structures
Authors: James R. Russell, Robert E. Strom, Daniel M. Yellin
Venue: ACM SIGPLAN Notices (1994)

We present a technique for analysing structural constraints on data aggregates in high-level languages. Our technique includes a formal constraint language and a dataflow algorithm for automatically checking equality constraints. The constraint language is used to augment the type information on program interfaces. For example, one can specify that a procedure must return aggregates A and B where each element in aggregate A points to some element in aggregate B, and that parameter C will have the properties of a rooted tree both on input and output. Our dataflow algorithm tracks the constraints which must apply at each statement in order for the procedure to satisfy its interface, and detects invalid programs which fail to satisfy the constraints on their interfaces. We apply our technique to several examples.Our work is motivated by the requirements for expressive interface definition languages for distributed systems, and by the desire to mechanically check program modules against their interfaces. Our analysis techniques also yield information which may enable compilers and stub generators to produce better implementations.
Accumulator-Based Compaction of Test Responses
Authors: Janusz Rajski, Jerzy Tyszer
Venue: IEEE Transactions on Computers (1993)

An accumulator-based compaction (ABC) scheme for parallel compaction of test responses is introduced. The asymptotic and transient coverage drop introduced by accumulators with binary and 1's complement adders is studied using Markov chain models. It is proven that the asymptotic coverage drop in ABC with binary adders is 2/sup -k/, where k is the number of bits in the adder that the fault can reach. In ABC with 1's complement adders, the asymptotic coverage drop for a fairly general class of faults is (2n-1)/sup -1/, where n is the total number of bits. The analysis of transient behavior relates the coverage drop with the probability of fault injection, the size of the accumulator, and the length of the test experiment. The process is characterized by damping factors derived for various values of these parameters.