ppxscal/embedding_network huggingface dataset:
The infinite version of an open communication complexity problem is independent of the axioms of set theory
Authors: Lance Fortnow, Stuart Kurtz, Duke Whang
Venue: ACM SIGACT News (1994)

In 1986, Babai, Frankl and Simon (BFS86) defined the polynomial hierarchy in communication complexity and asked whether Sigma;ee2 = Phi;ee2. In order to tackle this problem, researchers have looked at an infinite version. We recently became aware of a paper from 1979 where Miller [Mil79] shows that this infinite version is independent of the axioms of set theory. In this note we will describe Miller's result and give a simplified proof of one direction by showing that the continuum hypothesis implies that Sigma;r2 = Phi;r2p (R times; R).
The Riccati Equation for Optimal Control Problems with Mixed State-Control Constraints: Necessity and Sufficiency
Authors: Vera Zeidan
Venue: SIAM Journal on Control and Optimization (1994)

The goal of this paper is to conduct a complete study of second-order conditions for the optimal control problem with mixed state-control constraints. The conjugate point theory is presented and a necessary condition in terms of the corresponding Riccati equation is obtained. Sufficiency criteria are developed in terms of strengthened necessary conditions, including the Riccati equation. The results generalize the known ones for pure control constraints as well as for the mixed state-control constraints.
Cross-cultural perspectives on human-computer interaction: a report on the CHI'92 workshop
Authors: Wendy A. Kellogg, John C. Thomas
Venue: ACM SIGCHI Bulletin (1993)

The field of Human-Computer Interaction, and the CHI conference specifically are characterized by diversity. The field includes many professions and people from many cultures. Because of the intrinsic complexity of human-computer interaction as well as the wide variety of systems, tasks, users, and contexts that are addressed, this diversity of backgrounds and approaches is both inevitable and necessary. Nevertheless, this diversity also poses a serious dilemma. How can the science and practice of HCI cumulate effectively when the professionals deal with such different problems, and come from such a variety of professional and cultural backgrounds? The purpose of the workshop was to explore this issue. Readers will no doubt appreciate the analogy between this challenge of CHI and many international social issues facing people of the world today that require valuing and encouraging diversity while communicating and working together effectively to solve common problems.
Authorizations in relational database management systems
Authors: Elisa Bertino, Pierangela Samarati, Sushil Jajodia
Venue: Proceedings of the 1st ACM conference on Computer and communications security (1993)

This paper proposes two major extensions to the authorization model for System R relational database management system. The first extension concerns the revoke operation. The revised model provides for a new type of revoke operation, called noncascading revoke, in addition to the System R cascading revoke operation. Unlike cascading revoke, noncascading revoke operation does not recursively remove privileges from users. The second extension concerns negative authorization. The details related to its application are specified in the paper.
A practical data flow framework for array reference analysis and its use in optimizations
Authors: Evelyn Duesterwald, Rajiv Gupta, Mary Lou Soffa
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

Data flow analysis techniques have traditionally been restricted to the analysis of scalar variables. This retriction, however, imposes a limitation on the kinds of optimizations that can be performed in loops containing array references. We present a data flow framework for array reference analysis that provides the information needed in various optimizations targeted at sequential or fine-grained parallel architectures. The framework extends the traditional scalar framework by incorporating iteration distance values into the analysis to qualify the computed data flow solution during the fixed point iteration. Analyses phrased in this framework are capable of discovering recurrent access patterns among array references that evolve during the execution of a loop. Applications of our framework are discussed for register allocation, load/store optimizations, and controlled loop unrolling.
Young Straightening in a Quotient Sn-Module
Authors: Hélène Barcelo
Venue: Journal of Algebraic Combinatorics: An International Journal (1993)

We describe a straightening algorithm for the action of Sn on a certain graded ring {\cal {R}_\mu. The ring {\cal {R}_\mu appears in the work of C. de Concini and C. Procesi &lsqb;2&rsqb; and T. Tanisaki &lsqb;8&rsqb;, and more recently in the work of A. Garsia and C. Procesi &lsqb;4&rsqb;. This ring is a graded version of the permutation representation resulting from the action of Sn on the left cosets of a Young subgroup. As a corollary of our straightening algorithm we obtain a combinatorial proof of the fact that the top degree component of {\cal {R}_\mu affords the irreducible representation of Sn indexed by &mu;.
Persistence software: bridging object-oriented programming and relational databases
Authors: Arthur M. Keller, Richard Jensen, Shailesh Agarwal
Venue: Proceedings of the 1993 ACM SIGMOD international conference on Management of data (1993)

Building object-oriented applications which access relational data introduces a number of technical issues for developers who are making the transition to C++. We describe these issues and discuss how we have addressed them in Persistence, an application development tool that uses an automatic code generator to merge C++ applications with relational data. We use client-side caching to provide the application program with efficient access to the data.
Communication Costs for Parallel Volume-Rendering Algorithms
Authors: Ulrich Neumann
Venue: IEEE Computer Graphics and Applications (1994)

The computational expense of volume rendering motivates the development of parallel implementations on multicomputers. Parallelism achieves higher frame rates, which provide more natural viewing control and enhanced comprehension of 3D structure. Although many parallel implementations exist, we have no framework to compare their relative merits independent of host hardware. The article attempts to establish that framework by enumerating and classifying parallel volume-rendering algorithms suitable for multicomputers with distributed memory and a communication network. It determined the communication costs for classes of parallel algorithms by considering their inherent communication requirements.
Stability of event synchronisation in distributed discrete event simulation
Authors: Anurag Kumar, Rajeev Shorey
Venue: ACM SIGSIM Simulation Digest (1994)

This paper is concerned with the behaviour of message queues in distributed discrete event simulators. We view a logical process in a distributed simulation as comprising a message sequencer with associated message queues, followed by an event processor. We show that, with standard stochastic assumptions for message arrival and time-stamp processes, the message queues are unstable for conservative sequencing, and for conservative sequencing with maximum lookahead and hence for optimistic resequencing, and for any resequencing algorithm that does not employ interprocessor &ldquo;flow control&rdquo;. These results point towards certain fundamental limits on the performance of distributed simulation of open queueing networks.
Characterizing language identification by standardizing operations
Authors: Sanjay Jain, Arun Sharma
Venue: Journal of Computer and System Sciences (1994)

Notions from formal language learning theory are characterized in terms of standardizing operations on classes of recursively enumerable languages. Algorithmic identification in the limit of grammars from text presentation of recursively enumerable languages is a central paradigm of language learning. A mapping, F, from the set of all grammars into the set of all grammars is a standardizing operation on a class of recursively enumerable languages @? just in case F maps any grammar for any language L @? @? to a canonical grammar for L. Investigating connections between these two notions is the subject of this paper.
INFANT: a modular approach to natural language processing
Authors: Paul Buchheit
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

The INFANT System is a working natural language processing system that approaches language analysis through the integration of a large number of interdependent procedural modules. By themselves the modules perform specific, predictable, and rather mundane tasks; taken together, they make up an understanding system whose 'beliefs' and responses are varied and unpredictable. Thus a type of emergent behavior is demonstrated by the system. This paper describes the overall modular design of INFANT, and illustrates through sample conversations some of its capabilities and deficiencies.
QR-like algorithms for the nonsymmetric eigenvalue problem
Authors: J. B. Haag, D. S. Watkins
Venue: ACM Transactions on Mathematical Software (TOMS) (1993)

Hybrid codes that combine elements of the QR and LR algorithms are described. The codes can calculate the eigenvalues and, optionally, eigenvectors of real, nonsymmetric matrices. Extensive tests are presented as evidence that, for certain choices of parameters, the hybrid codes possess the same high reliability as the QR algorithm and are significantly faster. The greatest success has been achieved with the codes that calculate eigenvalues only. These can do the task in 15% to 50% less time than the QR algorithm.
Computing the future: whither computer science and engineering?
Authors: Juris Hartmanis, John Rice, Morton Lowengrub
Venue: Proceedings of the 1993 ACM conference on Computer science (1993)

The Computer Science and Telecommunications Board of the National Research Council recently released a report entitled Computing the Future: A Broader Agenda for Computer Science and Engineering. The report is intended as a first step in developing a vision of computer science and engineering that will carry the discipline into the 21st Century. Acknowledging the fraying of the social compact that has supported scientific research since World War II, pressures on academic science, and major changes in the computer industry, the report puts forward a view that the intellectual boundaries of the CS&E discipline should expand. The discipline should continue to support what has been traditionally been considered &ldquo;core&rdquo; computer science and engineering, but it should also learn to embrace rather than eschew computing problems that arise in domains outside the traditional core. Such problem domains include other sciences and areas with commercial or economic, significance. This broader agenda will have many benefits for CS E, including a rich set of intellectually challenging problems, greater social impact, and a wider variety of funding opportunities. Not surprisingly, this vision of the field in the 21st Century has generated considerable controversy and debate, as is appropriate for matters as important as these. A panel will briefly review the major judgments, priorities, and recommendations of the report, and differing perspectives on the report will be aired.
Efficient exact arithmetic for computational geometry
Authors: Steven Fortune, Christopher J. Van Wyk
Venue: Proceedings of the ninth annual symposium on Computational geometry (1993)

We experiment with exact integer arithmetic to implement primitives for geometric algorithms. Naive use of exact arithmetic&mdash;either modular or multiprecision integer&mdash;increases execution time dramatically over the use of floating-point arithmetic. By combining tuned multiprecision integer arithmetic and a floating-point filter based on interval analysis, we can obtain the effect of exact integer arithmetic at a cost close to that of floating-point arithmetic. We describe an experimental expression compiler that conveniently packages our techniques.
Software engineering project work in combined distance and on campus modes
Authors: Dave Oliver
Venue: ACM SIGCSE Bulletin (1994)

This paper describes the delivery of a Software Engineering subject taught in both Distance and On Campus modes. Rotated group working and Computer Mediated Communication were involved.
Fail-safe programming in compiler optimization
Authors: Jonathan L. Schilling
Venue: ACM SIGPLAN Notices (1993)

Compiler internal errors usually result in the immediate termination of a compilation. However, in the case of internal errors involving optimization, it may instead be possible to proceed with a less-optimized but otherwise correct compilation. A technique is presented that accomplishes this goal. The compiler contexts in which it may be used, and the benefits resulting from it, are discussed.
Developing an interprocedural optimizing compiler
Authors: Jon Loeliger
Venue: ACM SIGPLAN Notices (1994)

Compilers that perform interprocedural analysis require different user interfaces and different internal architectures than those used by compilers that process procedures independently. CONVEX Computer Corp. has developed a language-independent interprocedural optimizer that is packaged together with FORTRAN and C compilers in a product called the Application Compiler. User feedback and experience compiling large applications had a significant impact on the final user interface and system architecture.
Finding nonrecursive envelopes for Datalog predicate
Authors: Surajit Chaudhuri
Venue: Proceedings of the twelfth ACM SIGACT-SIGMOD-SIGART symposium on Principles of database systems (1993)

In this paper, we study the ability of data-independent conjunctive expressions (envelopes) to approximate fixpoint of Datalog predicates. We show that no effective procedure exists for finding envelopes that best approximate the fix-point (tight envelopes). Moreover, the problem of determining existence of tight envelopes is undecidable. The relationship between tight envelopes and the boundedness property is explored. Although the property of having tight envelopes seems weaker than boundedness, we note that a predicate can have a tight (lower) envelope iff it is bounded. On the other hand, there exist Datalog predicates that are not bounded but have tight (upper) envelopes. We relax our requirement for tight envelopes and settle for connected envelopes. An algorithm to determine connected envelopes for Datalog predicates is presented. We mention several applications of envelopes.
Stochastic performance models of parallel task systems (extended abstract)
Authors: Athar B. Tayyab, Jon G. Kuhl
Venue: ACM SIGMETRICS Performance Evaluation Review (1994)

This paper considers the class of parallel computations represented by directed, acyclic task graphs. These include parallel loops, multiphase algorithms, partitioning and merging algorithms, as well as any arbitrary parallel computation that can be structured by a task graph. The paper reviews the current state of the art in stochastic bound models of parallel programs and presents new stochastic bound performance models that predict the expected execution time of parallel programs on a given shared-memory multiprocessor system; and provide qualitative and quantitative description of the relationships between the structure of parallel programs, computation and synchronization behavior of the program, and architectural features of the underlying multiprocessor system.The models use a new formulation based on stochastic bound analysis and are solvable for a number of distribution functions. They are applicable to shared-memory multiprocessors with significantly different architectural and synchronization performance characteristics. The accuracy of the models is validated via several measurements on two different shared-memory multiprocessor systems, the Alliant FX/2800 and the Encore Multimax. The results show the models to be quite accurate, even when some of the modeling assumptions are violated. The maximum error of prediction ranges from about 10% to under 1%.
Using interface inheritance to address problems in system software evolution
Authors: Graham Hamilton, Sanjay Radia
Venue: Proceedings of the workshop on Interface definition languages (1994)

Two specific problems faced in large distributed systems are (1) evolving and managing different versions of an interface while minimizing the impact on existing clients, and (2) supporting the addition of auxiliary interfaces that are orthogonal to the main interface of an abstraction.In the context of the Spring distributed system, we addressed both problems using an object-oriented interface definition language. Different versions of an interface are represented as different types with an inheritance relationship that minimizes the impact on existing clients and allows easy management of versions.We distinguish between fundamental and auxiliary properties each of which are defined as separate types. Rather than use simple root inheritance, we use a combination of root and leaf inheritance. This provides flexibility in supporting auxiliary properties and allows us to add new auxiliary properties as the system evolves without forcing the system to be recompiled.The solutions have been tested and refined through their use in the Spring system.
A conceptual framework for evolving software processes
Authors: Reidar Conradi, Christer Fernström, Alfonso Fuggetta
Venue: ACM SIGSOFT Software Engineering Notes (1993)

Software processes are complex entities that may last for long periods of time and are carried out through the interaction of humans and computerized tools. They need to continuously evolve in order to cope with different kinds of changes or customizations both in the organization and in the technologies used to support software production activities.In recent years, many software process support technologies have been developed, and have currently been further extended and used in trial projects. Moreover, some research prototypes have generated commercial products, that are marketed and currently used in industrial organizations. Despite these significant efforts and results, however, there is still little conceptual characterization and assessment of the properties of software processes and related support environments. It is difficult to compare and assess existing approaches. Even a common characterization of the problems to be addressed seems to be problematic and difficult to achieve. This is particularly true when we consider the process evolution problem, for which it does not seem that a common view of the issue has been established yet.This paper aims at proposing a conceptual framework to describe and assess flexible and evolving software processes. It is based on the assumption that a software process is composed of two main components: a software production process to carry out software production activities, and a software meta-process to improve and evolve the whole software process.The general requirements and properties of the process domain are first discussed, and the meta-process concept is introduced. Then, we discuss several process related concepts and, in particular, the relationship between the meta-process and the rest of the software process. Methods and technologies needed to support the meta-process are highlighted and discussed. Finally, we apply the resulting framework to an example, in order to show the potential and expected benefits of the proposed approach.
Compiling real-time programs into schedulable code
Authors: Seongsoo Hong, Richard Gerber
Venue: Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation (1993)

We present a programming language with first-class timing constructs, whose semantics is based on time-constrained relationships between observable events. Since a system specification postulates timing relationships between events, realizing the specification in a program becomes a more straightforward process. Using these constraints, as well as those imposed by data and control flow properties, our objective is to transform the code so that its worst-case execution time is consistent with its real-time requirements. To accomplish this goal we first translate an event-based source program into intermediate code, in which the timing constraints are imposed on the code itself, and then use a compilation technique which synthesizes feasible code from the original source program.
Retrieval from hierarchical texts by partial patterns
Authors: Pekka Kilpeläinen, Heikki Mannila
Venue: Proceedings of the 16th annual international ACM SIGIR conference on Research and development in information retrieval (1993)

Structured texts (for example dictionaries and user manuals) typically have a heirarchical (tree-like) structure. We describe a query language for retrieving information from collections of hierarchical text. The language is based on a tree pattern matching notion called tree inclusion. Tree inclusion allows easy expression of queries that use the structure and the content of the document. In using it a user need not be aware of the whole structure of the database. Thus a language based on tree inclusion is data independent, a property made necessary because of the great variance in the structure of the texts.
Computer-aided adaptation of user interfaces: an INTERCHI '93 workshop report
Authors: David Benyon, Thomas Kühme, Uwe Malinowsi, Piyawadee Noi Sukaviriya
Venue: ACM SIGCHI Bulletin (1994)

The application of knowledge-based techniques to human-computer interaction is now a well-defined research area. Many experimental systems have been developed and there are a growing number of commercial applications. During the discussion at the INTERCHI '93 Research Symposium, it was speculated that intelligent interfaces would be emerging onto the market by 1996. The issue which concerned us and those attending the INTERCHI workshop on the topic was not 'should we have intelligent and adaptive interfaces?', nor was it 'how can we make a system adapt to people?' Based on the outcome of an earlier workshop on adaptive interfaces [1], we realized that more important issues lie in making users accept and understand adaptivity.
AUTOSPEC: Automatic Motor Specification System
Authors: Charles A. Suscheck, Gregory J. Komar
Venue: ACM SIGPLAN OOPS Messenger (1993)

The AUTOSPEC system is an automatic motor specification software system that primarily serves to non-interactively produce bill of materials from sales orders. At the core, the system applies Expert System and coordinated Relational Database technology to effect an object-oriented implementation. Computer Aided Software Engineering (CASE) tools supporting object-oriented analysis (OOA) and an object-oriented design (OOD) approach were used to provide a smooth transition of the software design effort into production at motor manufacturing plants. The powerful mechanisms of class inheritance, and forward chaining, as well as graphical program construction provided by the ProKappa Knowledge Base System are employed. Motif Graphical User Interface (GUI) development was carried out using UIM/X, a WYSIWYG screen development tool. The ORACLE Database Management System was used to provide data independence necessary for engineering system interfacing.