ppxscal/embedding_network huggingface dataset:
A study of the personality types of successful computer science majors (abstract)
Authors: Robert Leeper
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

This study is to determine the personality types of the Computer Science majors and to investigate whether there is correlation between success or failure in the Computer Science Program and specific personality types. Personality types were defined by C. G. Jung [1] and further articulated by Myers [2], Briggs and others. According to the theory an individual is born with a predisposition for certain personality preferences. There are four pairs of preference alternatives as follows: Extraverted or Introverted Sensing or Intuitive Thinking or Feeling Judging or Perceiving Hence an individual may be one of the sixteen personality types that are determined by a particular preference in each of the four pairs. For example: The individual's personality type may be Introverted - Sensing - Thinking - Perceiving or it may be Extraverted - Sensing - Feeling - Perceiving. David Keirsey [3] developed an instrument for determining personality types called the Keirsey Temperament Sorter. It consists of 70 questions whose answers determine the tendency in each of the four preference alternatives. This test will be administered to senior level students since they have demonstrated success in the program by progressing to the senior level. Results will be analyzed to determine if there is a tendency toward any of the preference alternatives. This test will be administered to senior level students since they have demonstrated success in the program by progressing to the senior level. Results will be analyzed to determine if there is a tendency toward any of the preference alternatives.
Mechanizing CSP Trace Theory in Higher Order Logic
Authors: A. J. Camilleri
Venue: IEEE Transactions on Software Engineering (1990)

How a mechanized tool for reasoning about CSP (communicating sequential processes) can be developed by customizing an existing general-purpose theorem prover based on higher-order logic is described. How the trace semantics of CSP operators can be mechanized in higher-order logic is investigated, and how the laws associated with these operators can be proved from their semantic definitions is shown. The resulting system is one in which natural-deduction style proofs can be conducted using the standard CSP laws.
Embedding Complete Binary Trees Into Butterfly Networks
Authors: Ajay K. Gupta, Susanne E. Hambrusch
Venue: IEEE Transactions on Computers (1991)

The authors present embeddings of complete binary trees into butterfly networks with or without wrap-around connections. Let m be an even integer and q=m+(log m)-1. The authors show how to embed a 2/sup q+1/-1-node complete binary tree T(q) into a (m+1)2/sup m+1/-node wrap-around butterfly B/sub w/(m+1) with a dilation of 4, and how to embed T(q) into a (m+2)2/sup m+2/-node wrap-around butterfly B/sub w/(m+2) with an optimal dilation of 2. They also present an embedding of a wrap-around butterfly B/sub w/(m) into a (m+1)2/sup m/-node no-wrap-around butterfly B(m) with a dilation of 3. Using this embedding it is shown that T(q) can be embedded into a no-wrap butterfly B(m+1) (resp. B(m+2)) with a dilation of 8 (resp. 5).
Cache replacement with dynamic exclusion
Authors: Scott McFarling
Venue: Proceedings of the 19th annual international symposium on Computer architecture (1992)

Most recent cache designs use direct-mapped caches to provide the fast access time required by modern high speed CPU's. Unfortunately, direct-mapped caches have higher miss rates than set-associative caches, largely because direct-mapped caches are more sensitive to conflicts between items needed frequently in the same phase of program execution. This paper presents a new technique for reducing direct-mapped cache misses caused by conflicts for a particular cache line. A small finite state machine recognizes the common instruction reference patterns where storing an instruction in the cache actually harms performance. Such instructions are dynamically excluded, that is they are passed directly through the cache without being stored. This reduces misses to the instructions that would have been replaced. The effectiveness of dynamic exclusion is dependent on the severity of cache conflicts and thus on the particular program and cache size of interest. However, across the SPEC benchmarks, simulation results show an average reduction in miss rate of 33% for a 32KB instruction cache with 16B lines. In addition, applying dynamic exclusion to one level of a cache hierarchy can improve the performance of the next level since instructions do not need to be stored on both levels. Finally, dynamic exclusion also improves combined instruction and data cache miss rates.
A parallel extendible scalable cellular automata machine: PE-SCAM
Authors: J. Dana Eckart
Venue: Proceedings of the 1992 ACM annual conference on Communications (1992)

The increasing interest in cellular automata has created the need for faster machines to execute such programs. PE&ndash;SCAM is a fine&ndash;grained SIMD architecture using a mesh of processors, with each processor corresponding to a single cell of the automata. Shift routing permits the use of arbitrarily large neighborhoods in cellular programs.
The Evolution of Instruction Sequencing
Authors: Robert F. Krick, Apostolos Dollas
Venue: Computer (1991)

The three distinct phases that constitute the sequencing of an instruction are determining the memory address that contains the instruction, fetching the instruction from memory, and executing the instruction. The evolution of instruction sequencing is traced, with attention focused on the influence of the available technology on the minimum time required for each of these phases and the resulting design decisions. Rather than absolute system performance. the interrelationship of these critical parameters is examined. Memory bandwidth, instruction buffers, caches, and the impact of reduced-instruction-set computers (RISCs) are discussed. Recent innovations are described, and the options and constraints that designers face with respect to future developments are evaluated.
MIDAS: Integrated Design and Simulation of Distributed Systems
Authors: Rajive L. Bagrodia, Chien-Chung Shen
Venue: IEEE Transactions on Software Engineering (1991)

An approach called MIDAS is described that supports the design of distributed systems via iterative refinement of hybrid models. A hybrid model is a partially implemented design where some components exist as simulation models and others as operational subsystems. It is an executable model and may be used to determine the stochastic performance characteristics of a partially elaborated design. MIDAS enhances the applicability of hybrid models in system design with its support for interrupts and its inclusion of distributed components in the partially implemented design. The authors describe how an existing simulation language may be extended to program hybrid models, and show how simulation algorithms may be adapted to execute hybrid models. A prototype MIDAS implementation is operational and was used to develop a set of applications. The experimental results of the exercise are also described.
The Representation Space Paradigm of Concurrent Evolving Object Descriptions
Authors: Aaron F. Bobick, Robert C. Bolles
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

A representation paradigm for instantiating and refining multiple, concurrent descriptions of an object from a sequence of imagery is presented. It is designed for the perception system of an autonomous robot that needs to describe many types of objects, initially detects objects at a distance and gradually acquires higher resolution data, and continuously collects sensory input. Since the data change significantly over time, the paradigm supports the evolution of descriptions, progressing from crude 2-D 'blob' descriptions to complete semantic models. To control this accumulation of new descriptions, the authors introduce the idea of representation space, a lattice of representations that specifies the order in which they should be considered for describing an object. A system, TraX, that constructs and refines models of outdoor objects detected in sequences of range data is described.
Machine translation using abductive inference
Authors: Jerry R. Hobbs, Megumi Kameyama
Venue: Proceedings of the workshop on Speech and Natural Language (1991)

<b>Machine Translation and World Knowledge.</b> Many existing approaches to machine translation take for granted that the information presented in the output is found somewhere in the input, and, moreover, that such information should be expressed at a single representational level, say, in terms of the parse trees or of "semantic" assertions. Languages, however, not only express the equivalent information by drastically different linguistic means, but also often disagree in what distinctions should be expressed linguistically at all. For example, in translating from Japanese to English, it is often necessary to supply determiners for noun phrases, and this in general cannot be done without deep understanding of the source text. Similarly, in translating from English to Japanese, politeness considerations, which in English are implicit in the social situation and explicit in very diffuse ways in, for example, the heavy use of hypotheticals, must be realized grammatically in Japanese. Machine translation therefore requires that the appropriate inferences be drawn and that the text be interpreted to some depth. Recently, an elegant approach to inference in discourse interpretation has been developed at a number of sites (e. g., Charniak and Goldman, 1988; Hobbs et al., 1990; Norvig, 1987), all based on the notion of abduction, and we have begun to explore its potential application to machine translation. We argue that this approach provides the possibility of deep reasoning and of mapping between the languages at a variety of levels.
A complex benchmark for logic programming and deductive databases, or who can beat the N-queens?
Authors: Werner Kießling
Venue: ACM SIGMOD Record (1992)

The N-queens problem with its long history and inherent complexity is a challenging benchmark target. We present our solution and performance results, hoping that this will stimulate a sort of benchmark competition for tough problems.
The design of the Triton nested relational database system
Authors: Tina M. Harvey, Craig W. Schnepf, Mark A. Roth
Venue: ACM SIGMOD Record (1991)

Unique database requirements of applications such as computer-aided design (CAD), computer-aided software engineering(CASE), and office information systems(OIC) have driven the development of new data models and database systems based on these new models. In particular, the goal of these new database systems is to exploit the advantages of complex data models that are more efficient (in terms of time and space) than their relational counterparts. In this paper, we describe the design and implementation of the Triton nested relational database system, a prototype system based on the nested relational data model. Triton is intended to be used as the backend storage and access component of the aforementioned applications. This paper describes the architecture of the Triton system, and compares the performance of the nested relational model versus the relational model using Triton. In addition, this paper evaluates the EXODUS extensible database toolkit used in the development of the Triton system including key features of the persistent programming language E and the EXODUS storage manager.
SNAP: Parallel Processing Applied to AI
Authors: Dan Moldovan, Wing Lee, Changhwa Lin, Minhwa Chung
Venue: Computer (1992)

It is argued that a viable solution for building future intelligent systems is to design special-purpose parallel computer architectures. The applications are restricted to those using semantic networks for knowledge representation. Reasoning on these networks is achieved with a marker-passing model of processing. The Semantic Network Array Processor (SNAP), a marker-passing parallel computer dedicated for natural-language and other knowledge-processing applications, is considered. Solutions for several nontrivial natural-language problems using the marker-passing approach are discussed.
Recent results from the ARM continuous speech recognition project
Authors: Martin Russell, Keith Ponting
Venue: Proceedings of the workshop on Speech and Natural Language (1990)

This paper describes some of the most recent work on continuous speech recognition using phoneme-level hidden Markov models (HMMs) which has been conducted at the UK Speech Research Unit as part of the ARM (Airborne Reconnaissance Mission) project [11]. The goal of the project is automatic recognition of spoken airborne reconnaissance reports. The project draws on many years of research undertaken in the UK by the Joint Speech Research Unit and the current RSRE Speech Research Unit, and also on the work on continuous speech recognition using sub-word HMMs which has been conducted under the current DARPA programme, particularly at MIT Lincoln Laboratory [5] and Carnegie Mellon University [3], and by the speech groups at IBM and BBN.
Compilation of functional languages by program transformation
Authors: Pascal Fradet, Daniel Le Métayer
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1991)

One of the most important issues concerning functional languages is the efficiency and the correctness of their implementation. We focus on sequential implementations for conventional von Neumann computers. The compilation process is described in terms of program transformations in the functional framework. The original functional expression is transformed into a functional term that can be seen as a traditional machine code. The two main steps are the compilation of the computation rule by the introduction of continuation functions and the compilation of the environment management using combinators. The advantage of this approach is that we do not have to introduce an abstract machine, which makes correctness proofs much simpler. As far as efficiency is concerned, this approach is promising since many optimizations can be described and formally justified in the functional framework.
Image Filtering Using Multiresolution Representations
Authors: Surendra Ranganath
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1991)

It is shown how multiresolution representations can be used for filter design and implementation. These representations provide a coarse frequency decomposition of the image, which forms the basis for two filtering techniques. The first method, based on image pyramids, is used for approximating the convolution of an image with a given mask. In this technique, a filter is designed using a least-squares procedure based on filters synthesized from the basic pyramid equivalent filters. The second method is an adaptive noise reduction algorithm. An optimally filtered image is synthesized from the multiresolution levels, which in this case are maintained at the original sampling density. Individual pixels of the image representation are linearly combined under a minimum mean square error criterion. This uses a local signal-to-noise ratio estimate to provide the best compromise between noise removal and resolution loss.
Using Motion from Orthographic Views to Verify 3-D Point Matches
Authors: Homer H. Chen, Thomas S. Huang
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1991)

The specific problem addressed by the authors is how to detect the true match of a fourth point from among candidate matches in a situation in which three points have already been matched. The two sets of points to be matched are both subject to measurement errors. The depth error is more dominant than errors in the other two coordinates; however, the exact statistical distribution of the measurement errors is not known. The authors present a new method for solving the problem. The method is based on the technique of motion analysis using orthographic views. It discards the noisy z (depth) coordinates and uses only the x and y coordinates of the points to verify the match. The effect of depth errors on the motion estimate is completely prevented. Results show that this method is substantially more effective than previous methods that use all three coordinates.
Object-oriented programming in C++
Authors: Richard J. Reid
Venue: ACM SIGCSE Bulletin (1991)

This paper describes a course that introduces students to object-oriented design, the C++ language and discreteevent simulation with animated displays. Students come to this course with a Pascal, C and Assembler background and progress through the object-oriented features of C++, completing a simulation project as a major course component. A video-tape series is used to provide C++ instruction.For the simulation project, students complete the controller portion of an elevator system involving multiple elevator cars in a multi-story building simulation. Student controllers are coupled with modules they cannot see within, but can communicate with, using the member functions provided at the object-oriented interface. The simulation and animated display give visual feedback of the performance of student control algorithms.
RIDDLE: A Foundation for Test Generation on a High-Level Design Description
Authors: Gabriel M. Silberman, Ilan Spillinger
Venue: IEEE Transactions on Computers (1991)

A formal approach to the analysis of a combinational circuit described at the high level is presented. It produces information conducive to the acceleration of test generation algorithms. This analysis yields, as its main product, information which can be used to reduce the amount of effort expended during backtracing, by guiding this process towards decisions (assignments) less likely to cause conflicts and minimizing the amount of work between backtracks. RIDDLE, an algorithm which performs this analysis in time linear in the number of signals, is introduced. Experimental results for the special case of combinational gate-level designs are also given.
Implementing stack simulation for highly-associative memories
Authors: Yul H. Kim, Mark D. Hill, David A. Wood
Venue: ACM SIGMETRICS Performance Evaluation Review (1991)

Prior to this work, all implementations of stack simulation [MGS70] required more than linear time to process an address trace. In particular these implementations are often slow for highly-associative memories and traces with poor locality, as can be found in simulations of tile systems. We describe a new implementation of stack simulation where the refrrenced block and its stack distance are found using a hash table rather than by traversing the stack. The key to this implementation is that designers are rarely interested in a continuum of memory sizes, but instead desire metrics for only a discrete set of alternatives (e.g., powers of two). Our experimental evaluation shows the run-time of the new implementation to be linear in address trace length and independent of trace locality. Kim, et al., [KHW91] present the results of this research in more detail.
Optimal Visual Motion Estimation: A Note
Authors: Minas E. Spetsakis, Yiannis Aloimonos
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

The problem of estimating 3D motion in an optimal manner using correspondences of features in two views is analyzed. The importance of having an optimal estimator is twofold: first, for the estimation itself and, second, for the bound it offers on how much sensitivity one can expect from a two-frame, point-based motion algorithm. The optimal estimator turns out to be nonlinear, and for that reason, techniques that provide very good initial guesses for the iterative computation of the optimal estimator are developed.
On modularity in integrated architectures
Authors: Steven Minton
Venue: ACM SIGART Bulletin (1991)

As computer scientists, most of us tend naturally to write modular systems. It is ingrained in our upbringing. The PRODIGY system (Minton et al. 1989, Carbonell et al. 1990) is an example of a highly modular system. PRODIGY has separate modules for planning, explanation-based learning, abstraction creation, experimentation and analogy, to name just a few. The system is rather traditional, in that it reflects the organization of the field of AI itself. Of course, an intelligent system need not be based on such a highly modular design. A system might be highly uniform throughout, with no obvious breakdown according to function, like some neural net models might suggest. Or a system might be very modular, but the functional breakdown might not look anything like that in the PRODIGY system, where each module corresponds to a different method for analysis or learning. In this brief paper, I speculate about the role of modularity in general intelligent systems and review the reasons why modularity might be an appropriate organizing principle.
Group graphs and computational symmetry on massively parallel architecture
Authors: Lewis Stiller
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

Group graphs are used to implement and reduce routing time in a domain whose associated operators are invariant under a group of invariances in a massively parallel environment. The algorithms are implemented in a program that solves chess end-games, part of whose space is invariant under a non-commutative crystallographic group.
Approximate representation theory of finite groups
Authors: László Babai, Katalin Fried
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

The asymptotic stability and complexity of floating point manipulation of representations of a finite group G are considered, especially splitting them into irreducible constituents and deciding their equivalence. Using rapid mixing estimates for random walks, the authors analyze a classical algorithm by J. Dixon (1970). They find that both its stability and complexity critically depend on the diameter d=diam(G,S) (S is the set that generates G). They propose a worst-case speedup by using Erdos-Renyi generators and modifying the Dixon averaging method. The overall effect in asymptotic complexity is a guaranteed (n log mod G mod )/sup O(1)/ running time.
A hands-on dataflow architecture/programming course
Authors: James T. Canning
Venue: ACM SIGCSE Bulletin (1991)

The University of Lowell's Department of Computer Science offers a course in data flow programming which provides students with the opportunity to run their programs on an actual, rather inexpensive dataflow machine. Students gain a much deeper understanding of the issues related to line grain parallel processing. The course not only surveys various dataflow architectures and languages, but also involves laboratory assignments where students must design, debug and execule dataflow programs.
Eliminating periodic packet losses in the 4.3-Tahoe BSD TCP congestion control algorithm
Authors: Zheng Wang, Jon Crowcroft
Venue: ACM SIGCOMM Computer Communication Review (1992)

The congestion control algorithm embedded in the 4.3-Tahoe BSD TCP implementation has dramatically improved congestion control over the Internet. However, several recent simulation studies on the dynamics of this algorithm has revealed that the algorithm exhibits clear oscillatory patterns in sending window size, round trip delay and bottleneck queue length. In this paper, we present a new congestion signal scheme and a dual traffic adjustment strategy. Simulation results show that our modifications can eliminate the periodic packet losses and substantially reduce the traffic oscillation.