ppxscal/embedding_network huggingface dataset:
Depth-Size Tradeoffs for Neural Computation
Authors: Kai-Yeung Siu, Vwani P. Roychowdhury, Thomas Kailath
Venue: IEEE Transactions on Computers (1991)

The tradeoffs between the depth (i.e., the time for parallel computation) and the size (i.e., the number of threshold gates) in neural networks are studied. The authors focus the study on the neural computations of symmetric Boolean functions and some arithmetic functions. It is shown that a significant reduction in the size is possible for symmetric functions and some arithmetic functions, at the expense of a small constant increase in depth. In the process, several neural networks which have the minimum size among all the known constructions have been developed. Results on implementing symmetric functions can be used to improve results about arbitrary Boolean functions. In particular, it is shown that any Boolean function can be computed in a depth-3 neural network with O(2/sup n/ /sup 2/) threshold gates; it is also proven that at least Omega (2/sup n/ /sup 3/) threshold gates are required.
The 2- and 3-modular characters of J3, its covering group and automorphism group
Authors: Robert A. Wilson
Venue: Journal of Symbolic Computation (1990)

A typical use of Parker's Meat-Axe in the calculation of modular character tables is described. Irreducible representations of the sporadic simple group J"3 are calculated, and the complete modular character tables in characteristics 2 and 3 are deduced.
An argument against scalable cache coherency
Authors: Norman Matloff
Venue: ACM SIGARCH Computer Architecture News (1991)

Recently there has been considerable interest in cache coherency protocols in shared-memory multiprocessor systems, particularly in protocols which are scalable, i.e. efficient in very large systems. In this position paper, it will be argued that in most multiprocessor applications scalability---or for that matter, systemwide cache coherency itself---is unnecessary, no matter how large the system is. Since even an efficient protocol will be a significant inhibitor of performance, it is then argued that systems not be built with systemwide coherency. Instead, a concept of "local coherency" is proposed. In this approach, though the shared-memory paradigm is retained and the system is still assumed to consist of a very large number of processors, hardware support for accessing shared variables exists only within groups of processors. Accordingly, it is asserted that the main research in cache coherency protocols should concentrate on developing efficient protocols for small and medium numbers of caches rather than on scalability.
Soft system methodology and is research: development of a new is design paradigm evaluation approach
Authors: Peter Kokol, Bruno Stiglic, Viljem Zumer
Venue: ACM SIGSOFT Software Engineering Notes (1991)

A sound and complete evaluation is a necessity in efficient and effective information system design. In the present paper we show how the Checklands Soft System Methodology can be used in the development of a new evaluation process, in the manner to overcome some of the greatest weaknesses of conventional ones.
Database and artificial intelligence integration: a challenge to academia
Authors: Pamela A. Taylor, Dana L. Wyatt
Venue: ACM SIGCSE Bulletin (1992)

Database (DB) and Artificial Intelligence (AI) courses have been long-standing offerings in computer science curriculums. Due to the present-day need for "intelligent" databases and "knowledge-base" management systems, the technologies of database and artificial intelligence are increasingly being integrated in research. Academia can give recognition to this important movement toward integration. An approach to teaching database and artificial intelligence concepts emphasizing their capabilities, limitations, and the need for integrating their technologies is proposed. An introduction gives a brief history of past and current practices. Reasons why the current routine should be modified are discussed. State-of-the-art information concerning current research in this area is presented, and finally, a course outline is suggested.
A quick introduction to the programming language MIKE
Authors: K. Coolsaet
Venue: ACM SIGPLAN Notices (1992)

MIKE is a new programming language developed by the author as a base language for the development of algebraic and symbolic algorithms. It is a structured programming language with a MODULA-2-like syntax supporting special features such as transparent dynamic memory management, discriminated union types, operator overloading, data abstraction and parametrized types. This text gives an overview of the main features of the language as of version 2.0.
Technique for universal quantification in SQL
Authors: Claudio Fratarcangeli
Venue: ACM SIGMOD Record (1991)

Universal quantification is expressed in ANSI SQL with negated existential quantification because there is no direct support for universal quantification in ANSI SQL. However, the lack of explicit support for universal quantification diminishes the userfriendliness of the language because some queries are expressed more naturally using universal quantification than they are using negated existential quantification. It is the intent of this paper to describe a technique to facilitate the construction of universal quantification queries in ANSI SQL. The technique is based upon a proposed extension to ANSI SQL to incorporate explicit general support for universal quantification.
X.400-based distributed application design methodology
Authors: Laurence Duchien, Valérie Gay, Eric Horlait
Venue: Proceedings of the 1992 ACM annual conference on Communications (1992)

The objective of this paper is to provide a distributed application design methodology using the X.400 standards. This one can be applied to two distributed application models: the client/server model and the peer to peer model. The client/server model relies on a relationship between a server entity and a client entity. The use of X.400 for this model is based on the defined relationship between the UA and the MS. The peer to peer model consists of a set of cooperating entities offering a service to the users. The use of X.400 for this model requires the creation of new MTS users and of a P2 type protocol enabling them to communicate. We analyze the advantages and disadvantages of each proposed alternative.
Placement of the Processors of a Hypercube
Authors: Ten-Hwang Lai, Alan P. Sprague
Venue: IEEE Transactions on Computers (1991)

The authors formalize the problem of minimizing the length of the longest interprocessor wire as the problem of embedding the processors of a hypercube onto a rectangular mesh, so as to minimize the length of longest wire. Where neighboring nodes of the mesh are taken as being at unit distance from one another, and where wires are constrained to be laid out as horizontal and vertical wires, the length of the wire joining nodes u and v of the mesh equals the graph-theoretic distance between u and v. The problem of minimizing delays due to interprocessor communication is then modeled as the problem of embedding the vertices of a hypercube onto the nodes of a mesh, so as to minimize dilation. Two embeddings which achieve dilations that (for large n) are within 26% of the lower bound for square meshes and within 12% for meshes with aspect ratio 2 are presented.
Automated Analysis of Concurrent Systems with the Constrained Expression Toolset
Authors: George S. Avrunin, Ugo A. Buy, James C. Corbett, Laura K. Dillon, Jack C. Wileden
Venue: IEEE Transactions on Software Engineering (1991)

The constrained expression approach to analysis of concurrent software systems can be used with a variety of design and programming languages and does not require a complete enumeration of the set of reachable states of the concurrent system. The construction of a toolset automating the main constrained expression analysis techniques and the results of experiments with that toolset are reported. The toolset is capable of carrying out completely automated analyses of a variety of concurrent systems, starting from source code in an Ada-like design language and producing system traces displaying the properties represented bv the analysts queries. The strengths and weaknesses of the toolset and the approach are assessed on both theoretical and empirical grounds.
Theorem-proving with resolution and superposition
Authors: Michael Rusinowitch
Venue: Journal of Symbolic Computation (1991)

We present a refutationally complete set of inference rules for first-order logic with equality. Except for x = x, no equality axioms are needed. Equalities are oriented by a well-founded ordering and can be used safely for demodulation without losing completeness. When restricted to equational logic, this strategy reduces to a Knuth-Bendix procedure.
Reliable computation with noisy circuits and decision trees&mdash;a general n log n lower bound
Authors: Rüdiger Reischuk, Bernd Schmeltz
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

Boolean circuits in which gates independently make errors with probability (at most) epsilon are considered. It is shown that the critical number crit(f) of a function f yields lower bound Omega (crit(f) log crit (f)) for the noisy circuit size. The lower bound is proved for an even stronger computational model, static Boolean decision trees with erroneous answers. A decision tree is static if the questions it asks do not depend on previous answers. The depth of such a tree provides a lower bound on the number of gates that depend directly on some input and hence on the size of a noisy circuit. Furthermore, it is shown that an Omega (n log n) lower bound holds for almost all Boolean n-input functions with respect to the depth of noisy dynamic decision trees. This bound is the best possible and implies that almost all n-input Boolean functions have noisy decision tree complexity Theta (n log n) in the static as well as in the dynamic case.
Gerunds and representations
Authors: Robert Bernecky, Roger K. W. Hui
Venue: ACM SIGAPL APL Quote Quad (1991)

Gerunds, verbal forms that can be used as nouns, are recognized as having utility in the realm of programming languages. We show that gerunds can be viewed as arrays of atomic representations of verbs (functions), in a way which is consistent with the syntax and semantics of APL, and which allows verbs to be first class objects in the language. We define derivations of verbs from gerunds in the J dialect of APL, and show how these derivations provide control structures for sequencing, selection (in the sense of generalized forms of CASE or SWITCH statements and IF/THEN/ELSE), iteration (DO UNTIL), recursion, and parallel computation (MIMD, or Multiple Instruction, Multiple Data). We conclude with alternative representations of verbs which are useful in other contexts.
Stewart varieties: a direct algebraic model for Stewart platforms
Authors: J.-P. Dedieu, G. Norton
Venue: ACM SIGSAM Bulletin (1990)

We present a new approach to modelling a triangular Stewart platform, which we regard as defining an octahedron. The lines joining the unlinked articulation points correspond to the diagonals of the octahedron. Using a classical determinant identity, we show that the squares on the diagonals satisfy a rather special system of non-linear algebraic equations. A set of bounded solutions (the "Stewart variety") easily yields the coordinates of a platform. In fact, each solution gives two platforms, which are symmetric with respect to the base plane. Using Newton's method, we give an effective algorithm to calculate the Stewart variety and the corresponding platform coordinates. We conclude with the algorithm at work on two examples.
Fault Diagnosis and Spare Allocation for Yield Enhancement in Large Reconfigurable PLAs
Authors: Sy-Yen Kuo, W. Kent Fuchs
Venue: IEEE Transactions on Computers (1992)

Reconfigurable logic and memory structures are an important means of increasing manufacturing yield as both circuit density and chip size continue to increase. Yield enhancement through reconfiguration, however, necessarily relies on accurate diagnosis of fault locations. Although a substantial body of literature exists concerning testing of logic arrays, little is known regarding diagnosis of the specific locations of multiple faults in such arrays. In the paper a fault diagnosis algorithm is presented for large programmable logic arrays (PLAs).
Debugging Concurrent Ada Programs by Deterministic Execution
Authors: Kuo-Chung Tai, Richard H. Carver, Evelyn E. Obaid
Venue: IEEE Transactions on Software Engineering (1991)

A language-based approach to deterministic execution debugging of concurrent Ada programs is presented. The approach is to define synchronization (SYN)-sequences of a concurrent Ada program in terms of Ada language constructs and to replay such SYN-sequences without the need for system-dependent debugging tools. It is shown how to define a SYN-sequence of a concurrent Ada program in order to provide sufficient information for deterministic execution. It is also shown how to transform a concurrent Ada program P so that the SYN-sequences of previous executions of P can be replayed. This transformation adds an Ada task to P that controls program execution by synchronizing with the original tasks in P. A brief description is given of the implementation of tools supporting deterministic execution debugging of concurrent Ada programs.
Formal semantics of SQL queries
Authors: M. Negri, G. Pelagatti, L. Sbattella
Venue: ACM Transactions on Database Systems (TODS) (1991)

The semantics of SQL queries is formally defined by stating a set of rules that determine a syntax-driven translation of an SQL query to a formal model. The target model, called Extended Three Valued Predicate Calculus (E3VPC), is largely based on a set of well-known mathematical concepts. The rules which allow the transformation of a general E3VPC expression to a Canonical Form, which can be manipulated using traditional, two-valued predicate calculus are also given; in this way, problems like equivalence analysis of SQL queries are completely solved. Finally, the fact that reasoning about the equivalence of SQL queries using two-valued predicate calculus, without taking care of the real SQL semantics can lead to errors is shown, and the reasons for this are analyzed.
Implementing JSD designs in Ada: a tutorial
Authors: W. L. Yeung, G. Topping
Venue: ACM SIGSOFT Software Engineering Notes (1990)

The Jackson System Development (JSD) method is widely recognized as viable for the design of real-time embedded systems. This paper discusses the implementation of JSD designs in Ada through a simulated lift control example.
Parallel program debugging with on-the-fly anomaly detection
Authors: Robert Hood, Ken Kennedy, John Mellor-Crummey
Venue: Proceedings of the 1990 ACM/IEEE conference on Supercomputing (1990)

We describe an approach for parallel debugging that coordinates static analysis with efficient on-the-fly access anomaly detection. We are developing on-the-fly instrumentation mechanisms for the structured synchronization primitives of Parallel Computing Forum (PCF) Fortran, the emerging standard for parallel Fortran. For programs without nested parallelism, it is possible to bound the cost of detection to a small constant at each shared access and thread creation point&mdash;in preliminary experiments this overhead is less than 40%. Our instrumentation techniques guarantee that we can isolate schedule-dependent behavior in a schedule-independent fashion. The result is that a single instrumented execution will either report sources of schedule-dependent behavior, or it will validate that all executions of the program on the same data compute the same result. When an instrumented execution is being used solely to find sources of schedule-dependent behavior, its cost can be reduced by slicing out computations that do not contribute to race conditions. Our approach to debugging is particularly well-suited for inclusion in a parallel program development environment; we describe our ongoing efforts to incorporate it in the ParaScope environment.
Evolutionary steps toward a distributed operating system: theory and implementation
Authors: Allison J. Mull, P. Tobin Maginnis
Venue: ACM SIGOPS Operating Systems Review (1991)

Generally speaking, distributed operating system (DOS) designers seem more concerned with resource sharing, global file system transparency, and implementation methodology. We feel that a DOS may provide the platform for linear speedup of applications if performance considerations are given highest priority in the design of the DOS. Work has been underway to test the implementation of such a DOS design in the MINIX environment.
Performance analysis of communications in static interconnection networks
Authors: Dikran S. Meliksetian, C. Y. Roger Chen
Venue: Proceedings of the 1992 ACM SIGMETRICS joint international conference on Measurement and modeling of computer systems (1992)

We present a model, based on a network of DX/D/1 queues, to predict the communication performance of static interconnection networks under various communication patterns. Our model predicts delay time distributions in the links as well as the first and second moments of the overall delay time of messages in the system. These predictions are verified by the results of simulations.
Minimizing capacity violations in a transshipment network
Authors: Tomasz Radzik
Venue: Proceedings of the third annual ACM-SIAM symposium on Discrete algorithms (1992)

The problem of minimizing capacity violation is a variation of the transshipment problem. It is equivalent to the problem of computing maximum mean surplus cuts which arises in the dual approach to the minimum cost network circulation problem. McCormick and Ervolina [15] proposed an algorithm which computes a sequence of cuts with increasing mean surpluses, and stops when an optimal one is found. The mean surplus of this cut is equal to the minimum possible maximum capacity violation. McCormick and Ervolina proved that the number of iterations in this algorithm is O(m). One iteration, i.e., finding the subsequent cut, amounts to computing maximum flow in an appropriate network. We prove that the number of iterations in this algorithm is &thgr;(n). This gives the best known upper bound O(n2m) for the problem. We also show a tight analysis of this algorithm for the case with integral capacities and demands, and present some improvements.
Models of Software Development Environments
Authors: Dewayne E. Perry, Gail E. Kaiser
Venue: IEEE Transactions on Software Engineering (1991)

A general model of software development environments that consists of structures, mechanisms, and policies is presented. The advantage of this model is that it distinguishes intuitively those aspects of an environment that are useful in comparing and contrasting software development environments. Four classes of environments-the individual, the family, the city. and the state-are characterized by means of a sociological metaphor based on scale. The utility of the taxonomy is that it delineates the important classes of interactions among software developers and exposes the ways in which current software development environments inadequately support the development of large systems. The generality of the model is demonstrated by its application to a previously published taxonomy that categorizes environments according to how they relate to language-centered, structure-oriented, toolkit, and method-based environments.
An asynchronous two-dimensional self-correcting cellular automaton
Authors: Weiguo Wang
Venue: Proceedings of the 32nd annual symposium on Foundations of computer science (1991)

Earlier work of P. Gacs and J. Reif (see J. Comput. Syst. Sci., vol.36, no.2, p.125-147 (1988)) on reliable computation using cellular automata is extended to asynchronous cellular automata. The goal is to find ways to implement computations of arbitrary size by a homogeneous asynchronous array of unreliable elementary components. An asynchronous two-dimensional cellular automaton is constructed so that given any computation and reliability requirement, a program can be found for such an automaton that performs the computation with probability that meets the reliability requirement. This is the strongest among the published results on reliable computation in an asynchronous environment. It is stronger than its asynchronous counterpart in the sense that it removes the assumption of a fault-free global synchronization clock underlying a synchronous system.
Perceptual Organization for Scene Segmentation and Description
Authors: Rakesh Mohan, Ramakant Nevatia
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1992)

A data-driven system for segmenting scenes into objects and their components is presented. This segmentation system generates hierarchies of features that correspond to structural elements such as boundaries and surfaces of objects. The technique is based on perceptual organization, implemented as a mechanism for exploiting geometrical regularities in the shapes of objects as projected on images. Edges are recursively grouped on geometrical relationships into a description hierarchy ranging from edges to the visible surfaces of objects. These edge groupings, which are termed collated features, are abstract descriptors encoding structural information. The geometrical relationships employed are quasi-invariant over 2-D projections and are common to structures of most objects. Thus, collations have a high likelihood of corresponding to parts of objects. Collations serve as intermediate and high-level features for various visual processes. Applications of collations to stereo correspondence, object-level segmentation, and shape description are illustrated.
Understandability of the software engineering method as an important factor for selecting a case tool
Authors: I. Rozman, J. Györkös, K. Rizmañ
Venue: ACM SIGSOFT Software Engineering Notes (1992)

The article highlights the understandability of a software engineering methodology as an important criterion for selecting a CASE tool. This aspect is treated through the comparison of learning properties for two very well known methodology on which the CASE tools are usually based on. The first one is SA-SD and the second one is JSD. In the purpose to compare both methodology a group of young engineers has been tested. Each of them wrote a seminar theme, answered a questionnaire and explained his observations. At the end of the paper, a general conclusion is presented.
Some Approaches to, and Illustrations of, Programming Language History
Authors: Jean E. Sammet
Venue: IEEE Annals of the History of Computing (1991)

This paper describes some factors in, approaches to, and specific elements of, programming language history. It first lists a number of general factors and approaches which can be used to discuss the history of programming languages. After presenting a life cycle for programming language development, it provides numerous illustrations of programming language history and chronology from many of the viewpoints indicated earlier. There is a brief discussion of relevant literature and a section indicating some of the reasons for the vast proliferation of programming languages. Various charts and lists are included. This paper should be viewed as one approach to considering the history of programming languages, rather than as a history of programming languages per se.