ppxscal/embedding_network huggingface dataset:
On Markovian Fragments of COCOLOG for Logic Control Systems
Authors: Yuanjun Wei, Peter E. Caines
Venue: SIAM Journal on Control and Optimization (1996)

The COCOLOG (Conditional Observer and Controller Logic) system is a partially ordered family of first-order logical theories expressed in the typed first-order languages $\{\clL_k;k\geq 0\}$ describing the controlled evolution of the state of a given partially observed finite machine $\cal M$. The initial theory of the system, denoted $Th_0$, gives the theory of $\cal M$ with no data being given on the initial state. Later theories, $\{Th(o_1^k);k \ge 1\}$, depend upon the (partially ordered lists of) observed input-output trajectories $\{o_1^k;k\geq 1\}$, where new data are accepted in the form of the new axioms $AXM^{obs}(\clL_k), k\geq 1$. A feedback control input $U(k)$ is determined by the solution of a collection of control problems posed in the form of a set of conditional control rules $CCR(\clL_k)$, such a set being paired with the theory $ Th(o_1^k)$ for each $k\geq 1$. In this paper, we introduce a restricted version of COCOLOG, called a system of Markovian fragments of COCOLOG, in which a smaller amount of information is communicated from one theory to the next. Such fragment theories are associated with a restricted set of candidate control problems, denoted $CCR(\clL^m_k), k\geq 1$. It is shown that a Markovian fragment theory $MTh(o_1^k)$ contains a large subset of $Th(o_1^k)$, which includes, in particular, the state estimation theorems of the corresponding full COCOLOG system and, for the set of control rules $CCR(\clL^m_k)$, has what is termed the same control reasoning power. Next, it is shown that proofs of theorems in the fragment systems are necessarily shorter than their proofs in the full COCOLOG systems. Finally some computer-generated examples are given, illustrating this increased theorem-proving efficiency.
Java as a first language: an evaluation
Authors: Frederick Hosch
Venue: ACM SIGCSE Bulletin (1996)

In this note, we outline some issues raised in considering the use of the programming language JavaTM to support a first course in software development. The course - essentially CS 1 - is centered on the design and implementation of simple objects, and employs an iterative specify/design/implement/test strategy to introduce data design and traditional procedural concepts. We enumerate some aspects of the Java language that attracted our interest, and identify some areas of the language design that could be modified to better meet our needs in an introductory computer science course.
Decoupled hardware support for distributed shared memory
Authors: Steven K. Reinhardt, Robert W. Pfile, David A. Wood
Venue: Proceedings of the 23rd annual international symposium on Computer architecture (1996)

This paper investigates hardware support for fine-grain distributed shared memory (DSM) in networks of workstations. To reduce design time and implementation cost relative to dedicated DSM systems, we decouple the functional hardware components of DSM support, allowing greater use of off-the-shelf devices.We present two decoupled systems, Typhoon-0 and Typhoon-1. Typhoon-0 uses an off-the-shelf protocol processor and network interface; a custom access control device is the only DSM-specific hardware. To demonstrate the feasibility and simplicity of this access control device, we designed and built an FPGA-based version in under one year. Typhoon-1 also uses an off-the-shelf protocol processor, but integrates the network interface and access control devices for higher performance.We compare the performance of the two decoupled systems with two integrated systems via simulation. For six benchmarks on 32 nodes, Typhoon-0 ranges from 30% to 309% slower than the best integrated system, while Typhoon-1 ranges from 13% to 132% slower. Four of the six benchmarks achieve speedups of 12 to 18 on Typhoon-0 and 15 to 26 on Typhoon-1, compared with 19 to 35 on the best integrated system. Two benchmarks are hampered by high communication overheads, but selectively replacing shared-memory operations with message passing provides speedups of at least 16 on both decoupled systems. These speedups indicate that decoupled designs can potentially provide a cost-effective alternative to complex high-end DSM systems.
Reference Model for Smooth Growth of Software Systems
Authors: Władysław M. Turski
Venue: IEEE Transactions on Software Engineering (1996)

This note presents a model of smooth software system evolution. The model assumes constant effort per release and takes into account the growth of system complexity.
On the $\lambda$-Number of $Q_n$ and Related Graphs
Authors: Marshall A. Whittlesey, John P. Georges, David W. Mauro
Venue: SIAM Journal on Discrete Mathematics (1995)

An $L(2, l)$-labeling of graph $G$ is an integer labeling of $V(G)$ such that adjacent vertices have labels that differ by at least 2 and such that vertices distance 2 apart have labels that differ by at least 1. The $\lambda$-number of $G, \lambda(G)$, is the minimum range over all $L(2, 1)$-labelings. We examine the properties of $\lambda$-labelings of the $n$-cube $Q_n$. Griggs and Yeh have determined $\lambda(Q_n)$ for $n \leq 5$ and have established $n + 3 \leq \lambda(Q_n) \leq 2n + 1$ for $n \geq 6$. We modify a technique used in coding theory to improve the upper bound. We also examine the $\lambda$-labelings of related graphs, such as the subdivision of the $n$-cube and the Cartesian products of paths.
Nondeterministic linear-time tasks may require substantially nonlinear deterministic time in the case of sublinear work space
Authors: Yuri Gurevich
Venue: Journal of the ACM (JACM) (1990)

A technique is developed for establishing lower bounds on the computational complexity of certain natural problems. The results have the form of time-space trade-off and exhibit the power of nondeterminism. In particular, a form of the clique problem is defined, and it is proved that: a nondeterministic log-space Turing machine solves the problem in linear time, but no deterministic machine (in a very general use of this term) with sequential-access input tape and work space n&sgr; solves the problem in time n1+&tgr; if &sgr; + 2&tgr; < 1/2.
Algorithm 759: VLUGR3: a vectorizable adaptive-grid solver for PDEs in 3D—Part II. code description
Authors: J. G. Blom, J. G. Verwer
Venue: ACM Transactions on Mathematical Software (TOMS) (1996)

This article describes an ANSI Fortran 77 code, VLUGR3, autovectorizable on the Cray Y-MP, that is based on an adaptive-grid finite-difference method to solve time-dependent three-dimensional systems of partial differential equations.
Bisimulation can't be traced
Authors: Bard Bloom, Sorin Istrail, Albert R. Meyer
Venue: Journal of the ACM (JACM) (1995)

In the concurrent language CCS, two programs are considered the same if they are bisimilar. Several years and many researchers have demonstrated that the theory of bisimulation is mathematically appealing and useful in practice. However, bisimulation makes too many distinctions between programs. We consider the problem of adding operations to CCS to make bisimulation fully abstract. We define the class of GSOS operations, generalizing the style and technical advantages of CCS operations. We characterize GSOS congruence in as a bisimulation-like relation called ready-simulation. Bisimulation is strictly finer than ready simulation, and hence not a congruence for any GSOS language.
Formal Methods Reality Check: Industrial Usage
Authors: Dan Craigen, Susan Gerhart, Ted Ralston
Venue: IEEE Transactions on Software Engineering (1995)

Based on a systematic survey and analysis of the use of formal methods in the development of a dozen industrial applications, we summarize the methods being used, characterize the styles of industrial usage, and provide recommendations for evolutionary enhancements to the technology base of formal methods.The industrial applications ranged from reverse engineering to system certification; code scale ranges from 1 KLOC to 10 KLOC's. Applications included a software infrastructure for oscilloscopes; a shutdown system for a nuclear generating station; a train protection system; an airline collision avoidance system; an engine monitoring system for shipboard engines; attitude control of satellites; security properties of both a smartcard device and a network; arithmetic units; transaction processing; a real-time database for a medical instrument; and a restructuring program for COBOL.
Size-Depth Tradeoffs for Algebraic Formulas
Authors: Nader H. Bshouty, Richard Cleve, Wayne Eberly
Venue: SIAM Journal on Computing (1995)

Some tradeoffs between the size and depth of algebraic formulas are shown. In particular, it is shown that, for any fixed $\epsilon > 0$, any algebraic formula of size $S$ can be converted into an equivalent formula of depth $O(\log S)$ and size $O(S^{1+\epsilon})$. This result is an improvement over previously known results where, to obtain the same depth bound, the formula size is $\Omega(S^{\alpha})$, with~$\alpha \ge 2$.
An Existence Result in a Problem of the Vectorial Case of the Calculus of Variations
Authors: Arrigo Cellina, Sandro Zagatti
Venue: SIAM Journal on Control and Optimization (1995)

We prove that the problem $$ \hbox{Minimize}\ \int_\Omega g(\Phi(\nabla T(x)))dx, \quad T\in T_B+W_0^{1,\infty}(\Omega,\rn) $$ admits at least one solution for any lower-semicontinuous extended valued function $g$, for any quasiaffine real-valued function $\Phi$, and for any piecewise-affine boundary datum $T_B$ such that $\Phi(\nabla T_B)$ is constant.
Parameter passing and control stack management in Prolog implementation revisited
Authors: Neng-Fa Zhou
Venue: ACM Transactions on Programming Languages and Systems (TOPLAS) (1996)

Parameter passing and control stack management are two of the crucial issues in Prolog implementation. In the Warren Abstract Machine (WAM), the most widely used abstract machine for Prolog implementation, arguments are passed through argument registers, and the information associated with procedure calls is stored in possibly two frames. Although accessing registers is faster than accessing memory, this scheme requires the argument registers to be saved and restored for back tracking and makes it difficult to implement full tail recursion elimination. These disadvantages may far outweigh the advantage in emulator-based implementations because registers are actually simulated by using memory. In this article, we reconsider the two crucial issues and describe a new abstract machine called ATOAM (yet Another Tree-Oriented Abstract Machine). The ATOAM differs from the WAM mainly in that (1) arguments are passed directly into stack frames, (2) only one frame is used for each procedure call, and (3) procedures are translated into matching trees is possible, and clauses in each procedure are indexed on all input arguments. The above-mentioned inefficiencies of the WAM do not exist in to he ATOAM because backtracking requires less bookkeeping operations, and tail recursion can be handled in most cases like a loop statement in procedural languages. An ATOAM-emulator-based Prolog system called B-Prolog has been implemented, which is available through anonymous ftp from ftp.kyutech.ac.jp (131.206.1.101) in the directory pub/Language/prolog.B-Prolog is comparable in performance with and can sometimes be significatly faster than emulated SICStus-Prolog. By measuring the numbers of memory and register references made in both systems, we found that passing arguments in stack is no worse than passing arguments in registers even if accessing memory is four times as expensive as accessing registers.
Sparse Polynomial Interpolation in Nonstandard Bases
Authors: Y. N. Lakshman, B. David Saunders
Venue: SIAM Journal on Computing (1995)

In this paper, we consider the problem of interpolating univariate polynomials over a field of characteristic zero that are sparse in (a) the Pochhammer basis or, (b) the Chebyshev basis. The polynomials are assumed to be given by black boxes, i.e., one can obtain the value of a polynomial at any point by querying its black box. We describe efficient new algorithms for these problems. Our algorithms may be regarded as generalizations of Ben-Or and Tiwari's (1988) algorithm (based on the BCH decoding algorithm) for interpolating polynomials that are sparse in the standard basis. The arithmetic complexity of the algorithms is $O(t^2 + t\log d)$ which is also the complexity of the univariate version of the Ben-Or and Tiwari algorithm. That algorithm and those presented here also share the requirement of $2t$ evaluation points.
Jacobi Angles for Simultaneous Diagonalization
Authors: Jean-Francois Cardoso, Antoine Souloumiac
Venue: SIAM Journal on Matrix Analysis and Applications (1996)

Simultaneous diagonalization of several matrices can be implemented by a Jacobi-like technique. This note gives the required Jacobi angles in close form.
On the Use of Certain Matrix Algebras Associated with Discrete Trigonometric Transforms in Matrix Displacement Decomposition
Authors: Enrico Bozzo, Carmine Di Fiore
Venue: SIAM Journal on Matrix Analysis and Applications (1995)

The authors extend some recent results of Di Fiore and Zellini [Linear Algebra Appl., to appear], obtaining new classes of formulas for the displacement operator-based decomposition of matrices. It is shown how an arbitrary matrix can be expressed as the sum of products of matrices belonging to matrix algebras associated with certain versions of sine and cosine transforms. Applications to the representation of the inverse of a Toeplitz and a Toeplitz plus Hankel matrix, with and without symmetry, are presented. Implications on the computation of the product of these matrices by a vector are discussed.
Rationalized three instruction machine
Authors: Sachin V. Chitnis, Manoranjan Satpathy, Sundeep Oberoi
Venue: ACM SIGPLAN Notices (1995)

The declarative nature of functional programming languages causes many difficulties in their efficient implementation on conventional machines. The problem is much harder when the language has non-strict (lazy) semantics. Abstract machines serve as an intellectual aid in bridging the semantic gap between such languages and the conventional von Neumann architecture. However they become more and more complex with time as efficiency considerations force the instruction set of the machine to grow in size. In this paper we explain the phenomenon in context of the Three Instruction Machine (TIM). We then define a rationalized instruction set for TIM that allows us to view all enhancements to TIM in a uniform way. This instruction set is quite close to RISC instructions and clearly identifies the key operations on closures. Translation of functional programs to our rationalized instruction set opens up scope for various local and global optimizations. We illustrate this by showing how to build control flow graphs and perform optimizations on it. Lazy arguments in functional programs make it hard to predict evaluation order statistically. We define the notion of pseudo-lazy arguments to statically expose the control flow information, wherever possible, for doing better flow analysis.
Reflection of developing user-level real-time thread packages
Authors: Shuichi Oikawa, Hideyuki Tokuda
Venue: ACM SIGOPS Operating Systems Review (1995)

In multimedia environments, applications use continuous-media data, such as video data and audio data, to provide users with a wide variety of interaction schemes with computers. Continuous-media applications require more efficient and flexible support from real-time threads than such research real-time systems. To fulfill such requirements, we have been developing user-level real-time threads, which are real-time threads implemented at the user level.We have implemented two user-level real-time thread packages on different operating system platforms, ARTS and RT-Mach. There were several issues, which we considered to design their architectures, such as compatibility, performance, correctness and accuracy. This paper describes the design issues, the lessons we have learned, and the discussions on their development.
A tensor product formulation of Strassen's matrix multiplication algorithm with memory reduction
Authors: B. Kumar, C.-H. Huang, P. Sadayappan, R. W. Johnson
Venue: Scientific Programming (1995)

In this article, we present a program generation strategy of Strassen's matrix multiplication algorithm using a programming methodology based on tensor product formulas. In this methodology, block recursive programs such as the fast Fourier Transforms and Strassen's matrix multiplication algorithm are expressed as algebraic formulas involving tensor products and other matrix operations. Such formulas can be systematically translated to high-performance parallel/vector codes for various architectures. In this article, we present a nonrecursive implementation of Strassen's algorithm for shared memory vector processors such as the Cray Y-MP. A previous implementation of Strassen's algorithm synthesized from tensor product formulas required working storage of size O(7$^n$) for multiplying 2$^n$ &times; 2$^n$ matrices. We present a modified formulation in which the working storage requirement is reduced to O(4$^n$). The modified formulation exhibits sufficient parallelism for efficient implementation on a shared memory multiprocessor. Performance results on a Cray Y-MP8/64 are presented.
The retreat from usability: user documentation in the post-usability era
Authors: Edmond H. Weiss
Venue: ACM SIGDOC Asterisk Journal of Computer Documentation (1995)

During the 1980s, developers and documentors collaborated on a joint mission: to make applications (and their manuals) as usable as possible: easy-to-learn, easy-to-operate, and therefore more useful. In recent years, however, developers have substantially retreated from this protective approach to users, placing a greater emphasis on flexibility, feature-richness, and customizability, none of which is consistent with the traditional, technical communicator's model of usability. New conceptions of software, and new expectations about users, may result in a "post-usability era," in which documentors will probably need to moderate their traditional rhetorical and pedagogical roles as protectors of users and advocates for the primacy of ease-of-use.
Estimators for Fault Tolerance Coverage Evaluation
Authors: David Powell, Eliane Martins, Jean Arlat, Yves Crouzet
Venue: IEEE Transactions on Computers (1995)

This paper addresses the problem of estimating the coverage of a fault tolerance mechanism through statistical processing of observations collected in fault injection experiments. A formal definition of coverage is given in terms of the fault and system activity sets that characterize the input space. Two categories of sampling techniques are considered for coverage estimation: sampling in the whole space and sampling in a space partitioned into classes. The estimators for each technique are compared by means of hypothetical examples. Techniques for early estimations of coverage are then studied. These techniques allow unbiased estimations of coverage to be made before all classes of the sampling space have been tested. Then, the ¿no-reply¿ problem that hampers most practical fault-injection experiments is discussed and an a posteriori stratification technique is proposed that allows the scope of incomplete tests to be widened by accounting for available structural information about the target system.Index Terms¿Coverage, fault injection, fault tolerance, estimation, sampling, variance reduction.
Complexity of parallel QR factorization
Authors: M. Cosnard, Y. Robert
Venue: Journal of the ACM (JACM) (1986)

An optimal algorithm to perform the parallel QR decomposition of a dense matrix of size N is proposed. It is deduced that the complexity of such a decomposition is asymptotically 2N, when an unlimited number of processors is available.
Strong deviations from randomness in m-sequences based on trinomials
Authors: Makoto Matsumoto, Yoshiharu Kurita
Venue: ACM Transactions on Modeling and Computer Simulation (TOMACS) (1996)

The fixed vector of any m-sequence based on a trinomial is explicitly obtained. Local nonrandomness around the fixed vector is analyzed through model-construction and experiments. We conclude that the initial vector near the fixed vector should be avoided.
Buffer management in shared-memory Time Warp systems
Authors: Richard M. Fujimoto, Kiran S. Panesar
Venue: Proceedings of the ninth workshop on Parallel and distributed simulation (1995)

Mechanisms for managing message buffers in Time Warp parallel simulations executing on cache-coherent shared-memory multiprocessors are studied. Two simple buffer management strategies called the sender pool and receiver pool mechanisms are examined with respect to their efficiency, and in particular, their interaction with multiprocessor cache-coherence protocols. Measurements of implementations on a Kendall Square Research KSR-2 machine using both synthetic workloads and benchmark applications demonstrate that sender pools offer significant performance advantages over receiver pools. However, it is also observed that both schemes, especially the sender pool mechanism, are prone to severe performance degradations due to poor locality of reference in large simulations using substantial amounts of message buffer memory. A third strategy called the partitioned buffer pool approach is proposed that exploits the advantages of sender pools, but exhibits much better locality. Measurements of this approach indicate that the partitioned pool mechanism yields substantially better performance than both the sender and receiver pool schemes for large-scale, small-granularity parallel simulation applications.The central conclusions from this study are: (1) buffer management strategies play an important role in determining the overall efficiency of multiprocessor-based parallel simulators, and (2) the partitioned buffer pool organization offers significantly better performance than the sender and receiver pool schemes. These studies demonstrate that poor performance may result if proper attention is not paid to realizing an efficient buffer management mechanism.
A New Formulation of State Constraint Problems for First-Order PDEs
Authors: Hitoshi Ishii, Shigeaki Koike
Venue: SIAM Journal on Control and Optimization (1996)

The first-order Hamilton--Jacobi--Bellman equation associated with the state constraint problem for optimal control is studied. Instead of the boundary condition which Soner introduced, a new and appropriate boundary condition for the PDE is proposed. The uniqueness and Lipschitz continuity of viscosity solutions for the boundary value problem are obtained.
Distributing a chemical process optimization application over a gigabit network
Authors: Robert L. Clay, Peter A. Steenkiste
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

We evaluate the impact of a gigabit network on the implementation of a distributed chemical process optimization application. The optimization problem is formulated as a stochastic Linear Assignment Problem and was solved using the Thinking Machines CM-2 (SIMD) and the Cray C-90 (vector) computers at PSC, and the Intel iWarp (MIMD) system at CMU, connected by the Gigabit Nectar testbed. We report our experience distributing the application across this heterogeneous set of systems and present measurements that show how the communication requirements of the application depend on the structure of the application. We use detailed traces to build an application performance model that can be used to estimate the elapsed time of the application for different computer system and network combinations. Our results show that the application benefits from the high-speed network, and that the need for high network throughput is increasing as computer systems get faster. We also observed that supporting high burst rates is critical, although structuring the application so that communication is overlapped with computation relaxes the bandwidth requirements.