ppxscal/embedding_network huggingface dataset:
Performance comparison of join on hypercube and mesh
Authors: Hyoung Jhang
Venue: Proceedings of the 1992 ACM annual conference on Communications (1992)

In this paper, we compare the performance of two join algorithms on a cube and on a multidimensional mesh architectures. The algorithms are nested-loop and sort-merge joins. The study confirms that a higher connectivity architecture is faster and has a wider performance bandwidth. The sort-merge join algorithm is better for a small number of nodes, but it becomes worse than the nested-loop join algorithm as the number of nodes gets larger and the join selectivity gets large, especially for the simpler mesh architecture. The study also shows that the 3-dimensional mesh architecture has performance comparable to the more complicated cube architecture for the medium number of nodes in a system.
Towards an algebraic theory of recursion
Authors: Yannis E. Ioannidis, Eugene Wong
Venue: Journal of the ACM (JACM) (1991)

An algebraic framework for the study of recursion has been developed. For immediate linear recursion, a Horn clause is represented by a relational algebra operator. It is shown that the set of all such operators forms a closed semiring. In this formalism, query answering corresponds to solving a linear equation. For the first time, the query answer is able to be expressed in an explicit algebraic form within an algebraic structure. The manipulative power thus afforded has several implications on the implementation of recursive query processing algorithms. Several possible decompositions of a given operator are presented that improve the performance of the algorithms, as well as several transformations that give the ability to take into account any selections or projections that are present in a givin query. In addition, it is shown that mutual linear recursion can also be studied within a closed semiring, by using relation vectors and operator matrices. Regarding nonlinear recursion, it is first shown that Horn clauses always give rise to multilinear recursion, which can always be reduced to bilinear recursion. Bilinear recursion is then shown to form a nonassociative closed semiring. Finally, several sufficient and necessary-and-sufficient conditions for bilinear recursion to be equivalent to a linear one of a specific form are given. One of the sufficient conditions is derived by embedding to bilinear recursion in an algebra.
Regular paper: Practical aspects of lateral and substrate PNP fabrication with a BICMOS process
Authors: D. R. Sparks, J. Fruth, J. Christenson, D. Adams
Venue: Microelectronic Engineering (1992)

The process integration and other issues associated with lateral and substrate PNP fabrication utilizing the various steps of a contemporary BICMOS process are outlined. The parameters affecting PNP performance examined are photolithographically determined base width, epitaxial silicon thickness and doping, buried layers, the diffusion steps selected for the formation of the emitter/collector, and the CMOS process enhancements. Hot carrier effects are also studied for the PNP devices.
The treadmill: real-time garbage collection without motion sickness
Authors: Henry G. Baker
Venue: ACM SIGPLAN Notices (1992)

A simple real-time garbage collection algorithm is presented which does not copy, thereby avoiding some of the problems caused by the asynchronous motion of objects. This in-place "treadmill" garbage collection scheme has approximately the same complexity as other non-moving garbage collectors, thus making it usable in a high-level language implementation where some pointers cannot be traced. The treadmill is currently being used in a Lisp system built in Ada.
Constructing Optimal Procedures for Testing Series Systems
Authors: Che-Liang Yang
Venue: IEEE Transactions on Computers (1990)

An efficient algorithm to construct testing procedures for optimally identifying a single defective unit in a series system is presented. A series system such as a local loop of telephone networks is modeled as a sequence of units. The costs incurred by the testing process are general; traveling costs and testing costs are taken into consideration. Although the model assumes that only one defective unit exists in the system, the testing tree still leads to the isolation of a defective unit if two or more exist. This occurs because whenever one proceeds to a subtree, a defective unit corresponding to a vertex within that subtree is certain to exist.
Planar graph decomposition and all pairs shortest paths
Authors: Greg N. Frederickson
Venue: Journal of the ACM (JACM) (1991)

An algorithm is presented for generating a succinct encoding of all pairs shortest path information in a directed planar graph G with real-valued edge costs but no negative cycles. The algorithm runs in O(pn) time, where n is the number of vertices in G, and p is the minimum cardinality of a subset of the faces that cover all vertices, taken over all planar embeddings of G. The algorithm is based on a decomposition of the graph into O(pn) outerplanar subgraphs satisfying certain separator properties. Linear-time algorithms are presented for various subproblems including that of finding an appropriate embedding of G and a corresponding face-on-vertex covering of cardinality O(p), and of generating all pairs shortest path information in a directed outerplannar graph.
The complexity of equivalence for commutative rings
Authors: H. B. Hunt,  III, R. E. Stearns
Venue: Journal of Symbolic Computation (1990)

We study the deterministic time complexity of the equivalence problems for formulas and for straight-line programs on commutative rings. A general theorem is presented, that yields sufficient conditions on a commutative ring, for these problems for the ring to require ''essentially as much deterministic time as the set of satisfiable 3CNF formulas''. As corollaries of this theorem, we characterize the deterministic time complexity of these two equivalence problems, for all finite commutative rings and for all commutative unitary rings of zero or prime characteristic.
Generalization of Min-Cut Partitioning to Tree Structures and its Applications
Authors: Gopalakrishnan Vijayan
Venue: IEEE Transactions on Computers (1991)

A generalization of the min-cut partitioning problem, called min-cost tree partitioning, is introduced. In the generalized problem. the nodes of a hypergraph G are to be mapped onto the vertices of a tree structure T, and the cost function to be minimized is the cost of routing the hyperedges of G on the edges of T. The standard min-cut problem is the simple case in which the tree T is a single edge connecting two vertices. Several VLSI design applications for this problem are discussed. An iterative improvement heuristic for this problem in which nodes of the hypergraph are moved between the vertices of the tree is described. The running time of a single pass of the heuristic for the unweighted version of the problem is Q(P*D*t/sup 3/), where P is the total number of pins in the hypergraph G, D is the maximum number of nodes in a hyperedge of G, and t is the number of vertices in the tree T. Several test results are discussed.
Comfort and experience with computing: are they the same for women and men?
Authors: Danielle R. Bernstein
Venue: ACM SIGCSE Bulletin (1991)

What produces comfort with computers and how is comfort related to computer achievement for men and women? This study looks at the effects of comfort and prior spreadsheet knowledge on the ability to design spreadsheets by management science students. Results showed that comfort with computing is significantly correlated with test performance for women; for men, mathematics ability and relevance to their future career are more important. The study suggests that the quality of women's initial computing instruction is very important in affecting what they will accomplish in the future.
Mis research directions: a survey of researchers' views
Authors: James T. C. Teng, Dennis F. Galletta
Venue: ACM SIGMIS Database (1991)

Several studies have addressed important issues for MIS research, but until now no empirical studies have been conducted to assess how MIS researchers themselves view the relatively new field. This survey of 397 MIS researchers revealed preferences for research methods and current areas of concentration, current studies being conducted, publication history, and other factors of interest. It found the subjects' assessment of the quality of MIS research relatively low and that they feel there is an over-emphasis on transient topics, rather than on topics of lasting significance. There is continuing evidence of fragmentation in the field. Few MIS researchers appear to rely on research frameworks. However, there is overall optimism that the quality of MIS research has been improving, and will continue to improve in the future. Implications for the future of MIS research are then discussed.
Comments on version 3.1 of draft ISO/IEC 10967: 1991 language compatible arithmetic
Authors: Corporate IFIP Working Group 2.5 (Numerical Software)
Venue: ACM SIGNUM Newsletter (1992)

An extremely encouraging development of the past several years for those concerned with constructing portable numerical software has been the increasingly widespread use of hardware that conforms to the IEEE standard for binary floating-point arithmetic (ISO/IEC 559:1989 and ANSI/IEEE 754-1985). This was designed with great care and has many features that assist the construction of software that is robust and executes rapidly.
Top-down parsing in Coco-2
Authors: H. Dobler
Venue: ACM SIGPLAN Notices (1991)

Coco-2 [Dobler90] is a new compiler compiler with two interesting features: It allows the specification of the lexical structure, syntax and semantics of a source language within a single document and it implements a new top-down parsing method. This paper focuses on the new parsing method that conveniently incorporates the evaluation of semantic actions in table-driven top-down parsers. The new method is called hybrid because it is a powerful combination of table-driven top-down syntax analysis and the handling of semantic evaluation as implemented in recursive descent parsers. The most notable fact of this method is, that it provides the benefits of table-driven top-down parsing and recursive descent while avoiding their drawbacks.
Private life in cyberspace
Authors: John Perry Barlow
Venue: Communications of the ACM (1991)

I have lived most of my life in a small Wyoming town, where there is little of the privacy which both insulates and isolates suburbanites. Anyone in Pinedale who is interested in me or my doings can get most of that information in the Wrangler Caf&eacute;. Between them, any five customers could probably produce all that is known locally about me&mdash;including a number of items that are well known but not true. me&mdash;including a number of items that are well known but not true.
A comparative analysis of two-phase-commit protocols (extended abstract)
Authors: Ouri Wolfson
Venue: Proceedings of the third international conference on database theory on Database theory (1990)

We compare the performance of four variants of the two-phase-commit paradigm, in the absence of failures. They are tree-commit ([SW1]), the decentralized ([Sk]), the linear ([G]), and the central-site ([LS]) algorithms. The performance measures are communication cost and communication time. We find that the communication cost of tree-commit is equal to that of the linear and central-site algorithms, its communication time cannot be worse, but it can be twice as fast. The communication time of the decentralized algorithm is better than that of tree-commit, whereas tree-commit wins as far as communication cost is concerned. When comparing the communication-complexity of the two algorithms, namely the product of the communication cost and the communication time, tree-commit wins.
Multilinear algebra and parallel programming
Authors: R. W. Johnson
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

We report on preliminary results of a joint project of the Center for Large Scale Computation at the City University of New York and the Department of Computer and Information Sciences at The Ohio State University to study the use of multilinear algebra in designing and implementing algorithms for linear computations. In particular, we discuss our experience in using these techniques on the Cray Y-MP [17] and to implement Strassen's matrix multiplication algorithm on the Encore Multimax [12,13,14].
Taming the Y operator
Authors: Guillermo Juan Rozas
Venue: Proceedings of the 1992 ACM conference on LISP and functional programming (1992)

In this paper I present a set of conceptually simple but involved techniques used by LIAR, the MIT SCHEME compiler, to generate good code when recursive procedures are specified in terms of suitable versions of the Y operator. The techniques presented are general-purpose analysis and optimization tools, similar to well-known techniques used in the analysis and optimization of applicative languages, that combine synergistically to enable LIAR to generate identical machine code for ordinary recursive definitions written using letrec and those written using suitable forms of Y.
Transformations between tree permutations and inversion tables
Authors: Harold W. Martin
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Associated with each permutation P = [x(1),x(2), &hellip; ,x(N)] of N (ordered) objects is its inversion table I(P) = {y(1),y(2), &hellip; ,y(N)}, a sequence of non-negative integers such that y(1) = 0 and, for i > 1, y(i) is the number of terms in {x(1), x(2), &hellip; ,x(i-1)} which are greater than or follow the term x(i). A tree permutation is a permutation whose inversion table {y(1), &hellip; ,y(N)} has the property that y(i+1) - y(i) is less than 2 for i = 1, 2, &hellip; , N-1; such an inversion table is called a 2-inversion table. Tree permutations of {1, 2, &hellip; , N} are used to represent binary trees having N nodes. O(N) time algorithms are given for converting tree permutations into their associated 2-inversion tables and vice-versa.
Homograph discrimination for intelligent interfaces via thesaural lexicons (abstract)
Authors: Donna M. Mooney, John R. Talburt
Venue: Proceedings of the 1990 ACM annual conference on Cooperation (1990)

Thesaural lexicons, in particular Roget's International Thesaurus, represent a rich knowledge-base of culturally validated semantic associations which extend over most of the English language. It has been shown that the Thesaurus can be a valuable tool in non-domain-specific approaches to natural language Artificial Intelligence. The importance of this approach is being able to go beyond the explicit semantic connections within categories of association into the implicit semantic connections between categories. The implementation of Robert Bryan's mathematical model for abstract thesauri is directed toward this implicit structure. Bryan's model defines a strong semantic connectedness between two entries by a structure called a Type-10 chain. Type-10 connectedness is also an equivalence relation which defines a partition of the thesaurus. These strongly connected components can be used as a tool for disambiguation of homographs (words which are spelled identically which may have different meanings) an important feature of any natural language interface. The implementation of the model involves decomposition by the recently developed Method of Quarters. This algorithm is used to reduce the combinatoric complexity of the model.. Using this method, the authors were able to compute all 139,638 Type-10 components and locate 23,858 Type-10 homographs at the semi-colon category level in Roget's International Thesaurus, 3rd Edition. The present focus of the research is to combine a feature-based parser which will decompose sentences into syntactic components and then resolve any semantic ambiguities by application of the implicit semantic structures in the lexicon of Type-10 homographs. This technique is now being developed for a Student Advising Expert System. This work can also be extended to use semantic structures not only as a lexicon for the disambiguation of homographs, but also for text generation and for abstract classification applications.
Using the Synthesizer-Generator to teach principles of programming language semantics
Authors: B. L. Kurtz, J. B. Johnston
Venue: Proceedings of the twenty-third SIGCSE technical symposium on Computer science education (1992)

The Synthesizer-Generator (or simply Syn-Gen) is a software tool for building context sensitive editors. It has been applied to a wide variety of applications, ranging from programing language editors to editors that insure balanced chemical equations. The context sensitivity is provided by using attribute grammars. We provide an introduction to Syn-Gen and illustrate how it can be used to build programming language editors that only allow input of source code that compiles successfully. We then discuss use of Syn-Gen in two classes: - the study of attribute grammars in a graduate course on the formal specification of programming languages; in this course students completed a lab exercise dealing with the implementation of a context sensitive editor for a mini programming language. - the study of operational semantics in a junior level course; students used an editor implemented with Syn-Gen to study programming language translation and also completed an assignment to implement a very small piece of this editor dealing with the resolution of label numbers at the assembly language level. We found that assignments involving the details of Syn-Gen implementation were challenging due to the syntactic complexity of the Syn-Gen system. For such assignments to be successful, it was necessary to keep a tight rein on this complexity. Using Syn-Gen as a context sensitive editor without worrying about implementation was quite successful. In the future, we plan to explore the use of Syn-Gen to develop editors for mini-languages to help teach introductory students about the various programming paradigms: imperative, functional and logical.
An integrated architecture for learning and planning in robotic domains
Authors: Michael Barbehenn, Seth Hutchinson
Venue: ACM SIGART Bulletin (1991)

Our system, GINKO, is fully implemented and integrates aspects of Learning, Planning, Execution, Perception, and Robotics In short, from Robotics we take our domains and we borrow the notion of planning in configuration space. We use Machine Learning techniques to classify regions of configuration space according to their qualitative behaviors. This corresponds to learning the conditional effects of robot operators. Our planner generates an abstract plan of transitions between regions of qualitative behavior in the configuration space. A concrete plan is generated by augmenting the abstract plan with execution monitors that sense critical aspects of the situations to ensure that a particular plan is being followed and that the regions from which the plan was derived are accurately characterized.
INC: a language for incremental computations
Authors: Daniel M. Yellin, Robert E. Strom
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1991)

An incremental computation is one that is performed repeatedly on nearly identical inputs. Incremental computations occur naturally in many environments, such as compilers, language-based editors, spreadsheets, and formatters. This article describes a proposed tool for making it easy to write incremental programs. The tool consists of a programming language, INC, and a set of compile-time transformations for the primitive elements of INC. A programmer defines an algorithm in INC without regard to efficient incremental execution. The transformations automatically convert this algorithm into an efficient incremental algorithm. INC is a functional language. The implementation of an INC program is a network of processes. Each INC function is transformed into a process that receives and transmits messages describing changes to its inputs and outputs. We give an overview to the language and illustrate the incremental techniques employed by INC. We present the static and incremental complexity bounds for the primitive INC functions. We also present some example programs illustrating INC's flexibility.
Adding rule-based reasoning to a demonstrational interface builder
Authors: Gene L. Fisher, Dale E. Busse, David A. Wolber
Venue: Proceedings of the 5th annual ACM symposium on User interface software and technology (1992)

This paper presents a demonstrational interface builder with improved reasoning capabilities. The system is comprised of two major components: an interactive display manager and a rule-based reasoner. The display manager provides facilities to draw the physical appearance of an interface and define interface behavior by graphical demonstration. The behavior is defined using a technique of stimulus-response demonstrations. With this technique, an interface developer first demonstrates a stimulus that represents an action that an end user will perform on the interface. After the stimulus, the developer demonstrates the response(s) that should result from the given stimulus. As the behavior is demonstrated, the reasoner observes the demonstrations and draws inferences to expedite behavior definition. The inferences entail generalizing from specific behavior demonstrations and identifying constraints that define the generalized behavior. Once behavior constraints are identified, the reasoner sends them to the display manager to complete the definition process. When the interface is executed by an end-user, the display manager uses the constraints to implement the run-time behavior of the interface.
The slide mechanism with applications in dynamic networks
Authors: Yehuda Afek, Eli Gafni, Adi Rosén
Venue: Proceedings of the eleventh annual ACM symposium on Principles of distributed computing (1992)

This paper presents a simple and efficient building block, called slide, for constructing communication protocols in dynamic networks whose topology frequently changes. We employ slide to derive (1) an end-to-end communication protocol with optimal amortized message complexity, and (2) a general method to efficiently and systematically combine dynamic and static algorithms. (Dynamic algorithms are designed for dynamic networks, and static algorithms work in networks with stable topology.) The new end-to-end communication protocol has amortized message communication complexity O(n) (assuming that the sender is allowed to gather enough data items before transmitting them to the receiver), where n is the total number of nodes in the network (the previous best bound was (O(m), where m is the total number of links in the network). This protocol also has bit communication complexity O(nD), where D is the data item size in bits (assuming data items are large enough; i.e., for D = &Ohgr;(nm log n)). In addition we give, as a byproduct, an end-to-end communication protocol using O(n2m) messages per data item, which is considerably simpler than other protocols known to us (the best known end-to-end protocol has message complexity O(nm)[AG91]). The protocols above combine in an interesting way several ideas: the information dispersal algorithm of Rabin [Rab89], the majority insight of [AFWZ88, AAF+], and the slide protocol.. The second application of slide develops a systematic mechanism to combine a dynamic algorithm with a static algorithm for the same problem, such that the combined algorithm automatically adjusts its communication complexity to the network conditions. That is the combined algorithm solves the problem in a dynamic network, and if the network stabilizes for a long enough period of time then the algorithm's communication complexity matches that of the static algorithm. This approach has been first introduced in [AM88] in the context of topology update algorithms.