ppxscal/embedding_network huggingface dataset:
Approximating sets with equivalence relations
Authors: W Marek, H Rasiowa
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

In various considerations of computer science (for instance in image processing and databases) one faces the following situation: Given a set (of points or of documents) one considers a descending sequence of equivalence relations (&ldquo;approximation spaces of order &Xgr;&rdquo;). These equivalence relations determine a sequence of closure operations Cli. Given a set X, the approximation sequence of X is simply <Cli(X)>i>&xgr;. We characterize here those sets X which satisfy the condition: X = &cap;{Cli(X): i>&Xgr;}.
The effect of join selectives on optimal nesting order
Authors: Akhil Kumar, Michael Stonebraker
Venue: ACM SIGMOD Record (1987)

A heuristic query optimizer must choose the best way to process an incoming query. This choice is based on comparing the expected cost of many (or all) of the ways that a command might be processed. This expected cost calculation is determined by statistics on the sizes of the relations involved and the selectivities of the operations being performed. Of course, such estimates are subject to error, and in this paper we investigate the sensitivity of the best query plan to errors in the selectivity estimates. We treat the common case of join queries and show that the optimal plan for most queries is very insensitive to selectivity inaccuracies. Hence, there is little reason for a data manager to spend a lot of effort making accurate estimates of join selectivities.
Just another piece of plastic in your wallet: the `Australian card' scheme
Authors: Roger Clarke
Venue: ACM SIGCAS Computers and Society (1988)

During 1985-87 the Australian Government developed a proposal for a national identification scheme. With public concern about the scheme's implications increasing, the Australia Card Bill was defeated in the Senate in November 1986 and again in April 1987. This paper outlines the proposal, and comments on its technical features, its economics, its implications and its prospects.
Firefly: A Multiprocessor Workstation
Authors: Charles P. Thacker, Lawrence C. Stewart, Edwin H. Satterthwaite,  Jr.
Venue: IEEE Transactions on Computers (1988)

The Firefly shared-memory multiprocessor workstation system consists of from one to nine VLSI VAX processors, each with a floating-point accelerator and a cache. The caches are coherent, so that all processors see a consistent view of main memory. The Firefly runs a software system (Topaz) that emulates the Ultrix system call interface, and in addition provides support for multiprocessing through multiple threads of control in a single address space. Communication is provided uniformly through the use of remote procedure call. The authors describe the goals, hardware, software system, and performance of the Firefly, and discuss the extent to which the development has been successful in providing software to take advantage of multiprocessing.
An object oriented system implementing KNOs
Authors: Eduardo Casais
Venue: Proceedings of the ACM SIGOIS and IEEECS TC-OA 1988 conference on Office information systems (1988)

We discuss a distributed object-oriented system written in LISP that implements KNOs (KNowledge acquisition, dissemination and manipulation Objects). The system emphasizes advanced features like object autonomy, mobility and dynamic inheritance. The objects are active, independent entities that can travel in a local area network and protect themselves from external aggressions. A dynamic inheritance mechanism enables them to modify their behaviour during their lifetime. We give a description of our system, illustrate its functionality with selected examples, and discuss its advantages for software development and Office Information Systems.
Efficient optimal pagination of scrolls
Authors: L. L. Larmore, D. S. Hirschberg
Venue: Communications of the ACM (1985)

Diehr and Faaland developed an algorithm that finds the minimum sum of key length pagination of a scroll of n items, and which uses O(n log n) time, solving a problem posed by McCreight. An improved algorithm is given which uses O(n) time.
A Construction Method of High-Speed Decoders Using ROM's for Bose-Chaudhuri-Hocquenghem and Reed-Solomon Codes
Authors: H. Okano, H. Imai
Venue: IEEE Transactions on Computers (1987)

In this paper, some efficient methods of solving equations over Galois field GF(2m) are proposed. Using these algorithms, decoders for triple-and quadruple-error-correcting Bose-Chaudhuri-Hocquenghem (BCH) codes are shown. More- over, we propose a new method of making high-speed decoders for double-error-correcting/triple-error-detecting BCH or Reed- Solomon (RS) codes by adding a simple error-identifying circuit to a decoder for double-error-correcting codes. By incorporating ROM's (read only memory) in a decoder, the complex logic circuits are eliminated and then we can easily construct a high- speed decoder. We evaluate the complexity of the decoders and show that each of them can be accommodated in a single chip LSI.
Riemann hypothesis and finding roots over finite fields
Authors: M-D A Huang
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

It is shown that assuming Generalized Riemann Hypothesis, the roots of &fnof;(x) = O mod p, where p is a prime and f(x) is an integral Abilene polynomial can be found in deterministic polynomial time. The method developed for solving this problem is also applied to prime decomposition in Abelian number fields, and the following result is obtained: assuming Generalized Riemann Hypotheses, for Abelian number fields K of finite extension degree over the rational number field Q, the decomposition pattern of a prime p in K, i.e. the ramification index and the residue class degree, can be computed in deterministic polynomial time, providing p does not divide the extension degree of K over Q. It is also shown, as a theorem fundamental to our algorithm, that for q, p prime and m the order of p mod q, there is a q-th nonresidue in the finite field Fpm that can be written as ao + a1w + &hellip; + am-1wm-1, where |a1| &le; cq2 log2(pq), c is an absolute effectively computable constant, and 1, w, &hellip;, wm-1 form a basis of Fpm over Fp. More explicitly, w is a root of the q-th cyclotomic polynomial over Fp. This result partially generalizes, to finite field extensions over Fp, a classical result in number theory stating that assuming Generalized Riemann Hypothesis, the least q-th nonresidue mod p for p,q prime and q dividing p - t is bounded by c log2p, where c is an absolute, effectively computable constant.
Efficient Complex Matrix Multiplication
Authors: Adly T. Fam
Venue: IEEE Transactions on Computers (1988)

A well-known algorithm for complex multiplication which requires three real multiplications and five real additions is observed not to require commutativity. The resulting extension of its applicability to complex matrices is examined. The computational savings are shown to approach 1/4. even if a real multiplication is not more computationally costly than a real addition. The computational cost function used is based on the number of equivalent real additions, with every real multiplication counted as equivalent to r real additions.
Improved upper and lower bounds for modal logics of programs
Authors: M Y Vardi, L Stockmeyer
Venue: Proceedings of the seventeenth annual ACM symposium on Theory of computing (1985)

We describe novel techniques for establishing improved upper and lower bounds for modal logics of programs: 1) We introduce hybrid tree automata. These automata seems to be doubly exponential more powerful than Rabin tree automata but their emptiness problem is only exponentially harder (nondeterministic exponential time vs. nondeterministic polynomial time). The satisfiability problem for several logics is reducible to the emptiness problem for hybrid tree automata. Using this reduction we show that the satisfiability problems for Streett's delta-PDL. Kozen's &mgr;-calculus and Parikh's game logic are solvable in nondeterministic exponential time, and the satisfiability problem for Emerson and Halpern's CTL and Vardi and Wolper's process logic (YAPL) are solvable in nondeterministic doubly exponential time. 2) We encode Turing machine computations by Kripke structures where every state in the structure represents a single tape cell. This yields a deterministic doubly exponential time lower bound for CTL and YAPL. 3) For variants of CTL and YAPL that deal only with finite computations we prove completeness for deterministic doubly exponential time.
The design and implementation of Concurrent Smalltalk
Authors: Yasuhiko Yokote, Mario Tokoro
Venue: ACM SIGPLAN Notices (1986)

ConcurrentSmalltalk is a programming language/system which incorporates the facilities of concurrent programming in Smalltalk-801. Such facilities are realized by providing concurrent constructs and atomic objects. This paper first gives an outline of ConcurrentSmalltalk. Then, the design of ConcurrentSmalltalk is described. The implementation of ConcurrentSmalltalk is presented in detail.
Source control using VM/SP and CMS
Authors: John Murray
Venue: ACM SIGSOFT Software Engineering Notes (1988)

This paper describes the Source Control System (SCS), an automated system which runs under IBM VM/SP with CMS. It is designed to manage source code data in medium-sized software development environments.
Visual programming&mdash;toward realization of user-friendly programming environments
Authors: T. Ichikawa, M. Hirakawa
Venue: Proceedings of the 1987 Fall Joint Computer Conference on Exploring technology: today and tomorrow (1987)

Programming is generally considered to be a complicated and time-consuming task even for professionals. This comes mostly from the unfriendliness of the programming environment. One of the possible ways to overcome this problem is by the utilization of visual information in programming. In this paper, we first observe some trials toward realization of user-friendly programming, and then give an outline of an iconic programming environment, HI-VISUAL, which the authors are now developing. In HI-VISUAL, objects dealt with by the system, such as data and programs are represented in terms of icons. Programming is carried out simply by arranging icons on the display. The system displays intermediate results of execution in the course of program development so that the user can proceed program development interactively. In addition to this interaction facility for programming, program development based on the top-down approach is also provided for programming in the large. Details of the program modules can be left unspecified until they become clear in the lower level of module hierarchy. Some computer displayed pictures are given for ease of understanding interactions between the user and the system.
Teaching of tree data structures using microcomputer graphics
Authors: G. Scott Owen
Venue: Proceedings of the seventeenth SIGCSE technical symposium on Computer science education (1986)

A set of procedures to graphically display ordered and unordered trees has been developed. The procedures have been used in several class demonstration programs to illustrate tree insertion, deletion, and balancing algorithms. The procedures are available for inclusion in student programs so that they can determine if their programs are working correctly. The procedures are written in Turbo Pascal for an IBM PC.
Software configuration&mdash;an NP-complete problem
Authors: Jerry Calabough
Venue: Proceedings of the conference on The 1987 ACM SIGBDP-SIGCPR Conference (1987)

Configuration Control File (CCF) production is very complex, thousands of code packages, data blocks and parameter values must be linked under many constraints including: Common data and code less than 8192 bytes Maximum of 5 registers per task All systems data must have common capabilities NP-complete problems are commonly known as knapsack or bin packing problems. They have no known algorithm which solves them in a time period bounded by a polynomial function of the number of inputs. Rules-of-thumb, or heuristics are the only practical approach to their solution. CCF segmentation to meet constraints discussed above is an example of Expert System technology applied to a classic NP-complete problem. Heuristics developed with traditional data processing techniques initially performed satisfactorily. However, as program development proceeded, Central Processor Unit (CPU) time for CCF production became a concern, both from a commitment of CPU resources and lost productivity. Traditional techniques failed to improve the heuristics and the project began to slip. Projected time to produce the CCF for a fully developed program was totally unacceptable, jeopardizing the project. Clearly another approach was required. Because existing heuristics were based on a concept of rules, research indicated an expert system using rules and a knowledge based approach had the highest probability of success. The paper emphasizes the development process of a knowledge based system from the perspective of the responsible project manager. The methodology is also applicable to common business problems.
Minimum Complexity FIR Filters and Sparse Systolic Arrays
Authors: Leonard A. Ferrari, P. V. Sankar
Venue: IEEE Transactions on Computers (1988)

The properties of B-spline approximation and the integral/derivative properties of convolution lead to efficient algorithms for the implementation of multidimensional FIR filters. The implementations are of minimum time complexity under the Nyquist criterion. The algorithm can easily be implemented using a sparse systolic array architecture. The resulting B-spline convolvers have much lower circuit complexity than systolic architectures based on conventional convolution algorithms. A two-dimensional hardware implementation based on simplifications of current architectures is presented.
Abstraction in recovery management
Authors: J. Eliot B Moss, Nancy D. Griffeth, Marc H. Graham
Venue: ACM SIGMOD Record (1986)

There are many examples of actions on abstract data types which can be correctly implemented with nonserializable and nonrecoverable schedules of reads and writes. We examine a model of multiple layers of abstraction that explains this phenomenon and suggests an approach to building layered systems with transaction oriented synchronization and roll back. Our model may make it easier to provide the high data integrity of reliable database transaction processing in a broader class of information systems. We concentrate on the recovery aspects here, a technical report [Moss et al 85] has a more complete discussion of concurrency control.
On the relationship between autoepistemic logic and parallel circumscription
Authors: M Gelfond, H Przymusinska
Venue: Proceedings of the ACM SIGART international symposium on Methodologies for intelligent systems (1986)

The purpose of this paper is to investigate the relationship between two approaches to the formalization of non-monotonic reasoning - J. McCarthy's approach based on the notion of Circumscription [Mc] and the Autoepistemic Logic approach of R. Moore [Mr]. Since these two approaches differ considerably in scope, we will limit our attention to the situation where some common ground can be found. Namely, we consider only the propositional case of parallel circumpsription, when all predicates of a formula T are circumscribed simultaneously.
Automatic design and implementation of language data types
Authors: S. T. Shebs, R. R. Kessler
Venue: Papers of the Symposium on Interpreters and interpretive techniques (1987)

Language implementation is in need of automation. Although compiler construction has long been aided by parser generators and other tools, interpreters and runtime systems have been neglected, even though they constitute a large component of languages like Lisp, Prolog, and Smalltalk. Of the several parts of a runtime system, the primitive datatype definitions present some of the most difficult decisions for the implementor. The effectiveness of type discrimination schemes, interactions between storage allocation and virtual memory, and general time/space tradeoffs are issues that have no simple resolution-they must be evaluated for each implementation. A formalism for describing implementations has been developed and used in a prototype designer of primitive data structures. The designer is a collection of heuristic rules that produce multiple designs of differing characteristics. Cost evaluation on machine code derived from those designs yields performance formulas, which are then used to estimate the designs' effect on benchmark programs.
A metamodel of information flow: a tool to support information systems theory
Authors: Niv Ahituv
Venue: Communications of the ACM (1987)

In this paper an axiomatic, fundamental metamodel of data flow is constructed. The components of the metamodel are the states along the flow of data: physical events, language (data), stored data, human data processing, and decision making. Transfers from one state to another are performed by functions: coding, keying, processing, perceptions, and human acting. The entire flow is evaluated by a value function. Each of the states and functions is rigorously described by means of definitions, axioms, and theorems. The main purpose of the metamodel is to provide a common framework for various models in MIS and consequently to remedy the "Tower of Babel" syndrome prevailing in this area. The way the metamodel can be used to develop other models in MIS is explained in the last part of the paper.
An object-oriented operating system interface
Authors: Juanita J. Ewing
Venue: Conference proceedings on Object-oriented programming systems, languages and applications (1986)

This paper discusses an object-oriented interface from the Smalltalk-80&trade; programming environment to a Unix-like operating system. This interface imposes an object-oriented paradigm on operating system facilities. We discuss some of the higher order abstractions that were created to make use of these facilities, and discuss difficulties we encountered implementing this interface. Several examples of cooperating Smalltalk and operating system processes are presented.
An introductory course in graphics
Authors: John D. McGregor
Venue: ACM SIGCSE Bulletin (1986)

The purpose of this paper is to report on some experiences in the planning and implementation of an introductory course on computer graphics. The course focused on topics of concern to the computer science major interested in developing graphics system software.
Business implications of knowledge-based systems. part II
Authors: John J Sviokla
Venue: ACM SIGMIS Database (1986)

The first section of this article showed how expert systems (ESs) evolved from a branch of the artificial intelligence (AI) field which focused on solving difficult, real world problems. A number of frameworks were put forth to show how ESs compare to other information systems (IS), and to help the practitioner identify valuable and feasible ES applications. Further, it was argued that a well-targeted ES may provide the user with a defensible competitive advantage, and because ESs are currently moving from universities into commerce it is now time to investigate their potential.This section moves on from the discussion of identification of ES opportunity into the issues of development and implementation. In comparison to other IS projects, ESs should prove more demanding. And even though the opportunity for strategic advantage may be available, the execution of a successful ES presents many managerial challenges. The discussion draws on previous literature to help identify issues which are likely to be encountered in practical application of ESs in business. Throughout the discussion, research opportunities are raised and the summary presents a research agenda.
The strong exponential hierarchy collapses
Authors: L. A. Hemachandra
Venue: Proceedings of the nineteenth annual ACM symposium on Theory of computing (1987)

The polynomial hierarchy, composed of the levels P, NP, PNP, NPNP, etc., plays a central role in classifying the complexity of feasible computations. It is not known whether the polynomial hierarchy collapses. We resolve the question of collapse for an exponential-time analogue of the polynomial-time hierarchy. Composed of the levels E (i.e., &Cup;c DTIME[2cn]), NE, PNE, NPNE, etc., the strong exponential hierarchy collapses to its &Dgr;2 level. E &ne; PNE = NPNE &Cup; NPNPNE &Cup; &middot;&middot;&middot; Our proof stresses the use of partial census information and the exploitation of nondeterminism. Extending our techniques, we also derive new quantitative relativization results. We show that if the (weak) exponential hierarchy's &Dgr;j+1 and &Sgr;j+1 levels, respectively E&Sgr;pj and NE&Sgr;pj, do separate, this is due to the large number of queries NE makes to its &Sgr;pj database.1 Our technique provide a successful method of proving the collapse of certain complexity classes.
A successful computer approach to the computer literacy course
Authors: Barbara A. Price
Venue: ACM SIGCSE Bulletin (1988)

Much emphasis has been placed on the core curriculum for the computer science major and this topic has been the focus of reports by the ACM and prominent educators (1, 4). Little attention seems to have been given, until recently, to the needs of the student not wishing to major in computer science but desiring an introduction to the discipline and an exposure to some common applications of the computer. This could be handled by two courses, computer science for the non-major and computer literacy. However, limited resources prevent the offering of two such courses at our college and a single course meeting both needs, introduction to the discipline and computer literacy, has evolved. We shall refer to this course as the computer literacy course.
Concepts for transaction recovery in nested transactions
Authors: Theo Haerder, Kurt Rothermel
Venue: ACM SIGMOD Record (1987)

The concept of nested transactions offers more decomposable execution units and finer grained control over recovery and concurrency as compared to 'flat' transactions. To exploit these advantages, especially transaction recovery has to be refined and adjusted to the requirements of the control structure. In this paper, we investigate transaction recovery for nested transactions. Therefore, a model for nested transaction is introduced allowing for synchronous and asynchronous transaction invocation as well as single call and conversational interfaces. For the resulting four parameter combinations, the properties and dependencies of transaction recovery are explored if a transaction is 'unit of recovery' and if savepoints within transactions are used to gain finer recovery units.
Efficient demand-driven evaluation. Part 2
Authors: Keshav Pingali, Arvind
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1986)

In Part 1 of this paper [5], we presented a scheme whereby a compiler could propagate demands through programs in a powerful stream language L. A data-driven evaluation of the transformed program performed exactly the same computation as a demand-driven evaluation of the original program. In this paper we explore a different transformation, which trades the complexity of demand propagation for a bounded amount of extra computation on some data lines.