ppxscal/embedding_network huggingface dataset:
Ensembles reconnaissables de mots biinfinis
Authors: Maurice Nivat, Dominique Perrin
Venue: Proceedings of the fourteenth annual ACM symposium on Theory of computing (1982)

The purpose of automata theory is to study and classify those properties of words that may be defined by a finite structure, say a finite automaton or a finite monoid. It seems natural to consider the same problem for infinite words. This amounts to studying the asymptotic behaviour of finite automata. As is well-known, this breaks the equivalence between determinism and non-determinism of finite automata. The study of the infinite behaviour of finite automata is based on a deep theorem due to B-&-uuml;chi and Mc Naughton: the recognizable sets of infinite words are the finite boolean combinations of deterministic ones (i.e. recognized by deterministic automata). The aim of this paper is to build an analogous theorem for two-sided infinite sequences. We define a biinfinite word as the equivalence class under the shift of a two-sided infinite sequence. The recognizable sets of biinfinite words are defined in a natural way and one is led to a two-sided notion of determinism. This notion seems to be new and justifies the consideration of biinfinite words. The main result of this paper is the extension to biinfinite words of the theorem of B-&-uuml;chi and Mc Naughton: the recognizable sets of biinfinite words are the finite boolean combinations of deterministic ones (Theorem 3.1). There exist three available proofs of B-&-uuml;chi-Mc Naughton's theorem. The original one by Mc Naughton [4] is hard to read. The proof given by Eilenberg in his book [2] has been constructed by Sch-&-uuml;tzenberger and Eilenberg from Mc Naughton's proof; it is similar to that of Rabin [5]. Finally, Sch-&-uuml;tzenberger gave a further proof in [6], which makes the argument more direct by using the methods of the theory of finite monoids. The proof of our main result follows closely Sch-&-uuml;tzenberger's method. This method allows to reduce the two-sided case to the one-sided case, although this seems very difficult to obtain directly. In the first section, we briefly recall the theory of the one-sided infinite behaviour of finite automata. In particular, we give Sch-&-uuml;tzenberger's proof of B-&-uuml;chi-Mc Naughton's theorem. The elements of this proof are used in the proof of our main result. In the second section we define the notions of biinfinite word, biautomaton and deterministic biautomaton. The last section contains the proof of our main result.
Invisibility coherence for faster scan-line hidden surface algorithms
Authors: Gary A. Crocker
Venue: Proceedings of the 11th annual conference on Computer graphics and interactive techniques (1984)

Invisibility coherence is a new technique developed to decrease the time necessary to render shaded images by existing scan-line hidden surface algorithms. Invisibility coherence is a technique for removing portions of a scene that are not likely to be visible. If a large portion of the scene is invisible, as is often the case in three-dimensional computer graphics, the processing time eliminated may be substantial. Invisibility coherence takes advantage of the observation that a minimal amount of processing needs to be done on objects (polygons, patches, or surfaces) that will be hidden by other objects closer to the viewer. This fact can be used to increase the efficiency of current scan-line algorithms, including both polygon-based and parametrically curved surface-based algorithms. Invisibility coherence was implemented and tested with the polygon hidden surface algorithm for constructive solid geometry developed by Peter Atherton [1]. The use of invisibility coherence substantially increases the efficiency of this scan-line algorithm. Invisibility coherence should work as well or even better with other scan-line hidden surface algorithms, such as the Lane-Carpenter, Whitted, and Blinn algorithms for parametrically curved surfaces [2]., or the Watkins, Romney, and Bouknight algorithms for polygons [3, 4, 5].
Linear time algorithm for isomorphism of planar graphs (Preliminary Report)
Authors: J. E. Hopcroft, J. K. Wong
Venue: Proceedings of the sixth annual ACM symposium on Theory of computing (1974)

The isomorphism problem for graphs G1 and G2 is to determine if there exists a one-to-one mapping of the vertices of G1 onto the vertices of G2 such that two vertices of G1 are adjacent if and only if their images in G2 are adjacent. In addition to determining the existence of such an isomorphism, it is useful to be able to produce an isomorphism-inducing mapping in the case where one exists. The isomorphism problem for triconnected planar graphs is particularly simple since a triconnected planar graph has a unique embedding on a sphere [6]. Weinberg [5] exploited this fact in developing an algorithm for testing isomorphism of triconnected planar graphs in O(|V|2) time where V is the set consisting of the vertices of both graphs. The result has been extended to arbitrary planar graphs and improved to O(|V|log|V|) steps by Hopcroft and Tarjan [2,3]. In this paper, the time bound for planar graph isomorphism is improved to O(|V|). In addition to determining the isomorphism of two planar graphs, the algorithm can be easily extended to partition a set of planar graphs into equivalence classes of isomorphic graphs in time linear in the total number of vertices in all graphs in the set. A random access model of computation (see Cook [1]) is assumed. Although the proposed algorithm has a linear asymptotic growth rate, at the present stage of development it appears to be inefficient on account of a rather large constant. This paper is intended only to establish the existence of a linear algorithm which subsequent work might make truly efficient.
A model for program complexity analysis
Authors: Carma L. McClure
Venue: Proceedings of the 3rd international conference on Software engineering (1978)

A frequently stated objective of structured programming is to control program complexity. However, since the notion of complexity is not well under-stood and the existing techniques for measuring complexity are crude, it is difficult to determine if indeed structured programming can achieve this objective. The purpose of this paper is two-fold: to discuss the probable sources of complexity in a well-structured program to present a methodology for measuring and controlling complexity in a well-structured program.
A methodology for programming a pipeline array processor
Authors: Danny Cohen
Venue: Proceedings of the 11th annual workshop on Microprogramming (1978)

In this note a recursive filter implementation is discussed, analyzed and programmed in the most efficient way for the FPS-AP120B array processor. The purpose of this note is not only to demonstrate a good technique for programming this filter (even though it is a noble goal by itself), but to demonstrate the methodology involved. The FPS-AP120B array processor was chosen because it has microprogrammed control parallel pipeline architecture, which is typical for a wide class of high performance array processors.
Experimental design in computer simulation
Authors: William E. Biles
Venue: Proceedings of the 11th conference on Winter simulation - Volume 1 (1979)

This paper describes the application of experimental design techniques to computer simulation. Three principal areas of experimental design are considered: (1) factor screening experiments; (2) experiments of comparison; and (3) response surface methodology.
Implementation of a GOAL PROGRAM
Authors: William Powell
Venue: Proceedings of the 3rd annual ACM SIGUCCS conference on User services (1975)

We all need specific goals to guide us. Goals give you direction. Recognizing that we need goals is the first step toward choosing and achieving those goals. By making each goal specific, you have definite deadlines to aim for. Get a statement of your specific goals down on paper. Attached is an outline of a GOALS PROGRAM. The methods and procedures are described for the following: 1. Goal Setting 2. Goal Review 3. Group Review 4. Progress Review 5. Accomplishment Report 6. New Goal Preparation
On a formal model of the tasking concept in Ada
Authors: Hans Henrik Løvengreen, Dines Bjørner
Venue: Proceedings of the ACM-SIGPLAN symposium on The ADA programming language (1980)

This paper describes the August 1980 state of the development of a formal model of the Ada tasking concept. The model is being developed at the Department of Computer Science, Technical University of Denmark in collaboration with the Danish Datamatics Centre as part of a full Ada compiler development project summarized below. The paper includes a short characterization of the (present) tasking concepts in Ada on which the model is based. The model description is rather informal to let you have an idea about the modelling principles. In appendix A a detailed example is given, unfolding the course of a rendezvous. The paper ends with a sketch of how an implementation can be systematically derived from the formal model.
Building synergistic EDP teams
Authors: Kathryn M. Bartol
Venue: Proceedings of the fifteenth annual SIGCPR conference (1977)

A team is termed &ldquo;synergistic&rdquo; when the members working together are able to achieve results significantly beyond what could be expected from the same team members working relatively independently. Unfortunately, placing several employees into a work group and calling them a team does not necessarily result in the desired synergy. On the contrary, a team can function so ineffectively as to actually reduce the potential output of various individual members. Therefore, it is not surprising that Powers and Dickson (1973) found no direct relationship between MIS project success and such elements as the systems experience of project personnel or the utilization of a project team composed of MIS staff and user personnel. To achieve a synergistic effect, teams must be carefully built and developed through the assistance of EDP management. This paper draws on the literature related to group behavior, decision making, and organizational structure to identify a number of factors which affect the ability of EDP teams to achieve synergistic effects. Two types of factors are discussed: (1) structural factors and (2) process factors. Structural factors focus on the basic parameters within which the team operates and include team size, appropriate choices of technical expertise, resource allocation, and reward systems. Process factors relate to the ongoing operations and interrelationships of the team and include such elements as interpersonal skills, modes of conflict resultion, and team leadership. Failure of EDP management to concern itself with the structural and process factors of teams could doom the team concept in situations where, with proper attention to team building, a team could deliver the best results.
Macrosimulation with Quasi-general Symbolic FET Macromodel and Functional Latency
Authors: H. Y. Hsieh, N. B. Rabbat
Venue: Proceedings of the 16th Design Automation Conference (1979)

This paper evaluates our attempt to solve the large network analysis problems in the time domain by use of a simulation method with computation efficiency and program simplicity. We present a Quasi-general Symbolic FET Macromodel (QGSM) which can represent many different logic function gates; hence, the simulation program needs only one macromodel QGSM. We also discuss the Functional Latency Concept (FLC). With FLC we can avoid analyzing more inactive subnetworks to realize savings in CPU time. Finally, we describe a triple-iteration loop method which can be readily incorporated into the time-domain analysis. The experimental program exhibits topological flexibility, computational accuracy, and programming simplicity.
Combinatory foundation of functional programming
Authors: Corrado Böhm
Venue: Proceedings of the 1982 ACM symposium on LISP and functional programming (1982)

A proposal is described for embedding FP and a part of FFP into a system C(IN)V of Combinatory Logic generated by the 6-tuple of combinators (A,B,C*,O,L,D) under the operation of application. At the same time C(IN)V is viewed as an algebraic extension of elementary arithmetic, including addition multiplication and exponentiation, leading to a non commutative semi-ring with an infinity of zero (infinite)-like elements. Two interesting submonoids have been selected: L&ordm; able to represent the set of FP-Sequences and L+ able to represent the set of FP-Constructions. All basic objects forming operators like Composition, Apply To All Condition and Insert Right are then efficiently expressed inside C(IN)V. The same is done for some operators belonging to FFP as Lifting and the APPLY of LISP establishing a basis for a future reduction (operational) semantics of FP.
Some implications of shared variables
Authors: Adin D. Falkoff
Venue: Proceedings of the eighth international conference on APL (1976)

Recognition of shared variables as the fundamental means of communication between concurrently operating processes has important implications for the design of systems and programming languages. As a consequence, current APL systems, such as APLSV, embody two shared variable facilities: one for establishing temporary interfaces between system components, and the other one for defining parts of the permanent interface between an APL program and the underlying processor. These are treated in depth in this paper. More general implications for language and system design, system programming, and system performance are briefly noted. It is observed, for example, that languages that attempt to communicate with the environment without the explicit use of shared variables do not have a true communication facility, and therefore tend to absorb more and more of the environment within their own formal structure.
Control schemes for VLSI microprocessors
Authors: Gary R. Burke
Venue: Proceedings of the 15th annual workshop on Microprogramming (1982)

As microprocessors move into the VLSI era, the number and complexity of the functions they are expected to perform increases beyond the capability of conventional control schemes. This paper discusses the fundamental requirements of such a control system, and explores the possibility of using external microcode control.
Experimental evaluation of a multiprogrammed computer system
Authors: Y. V. Reddy
Venue: Proceedings of the 1975 annual conference (1975)

This paper reports on the design and analysis of a statistical experiment conducted on a &ldquo;live&rdquo; job stream to determine the effect of segment size used for storage allocation on the system performance. Performance measures selected are turnaround time, cost and CPU utilization. The experiment consists of one factor, the segment size, at five levels. Uncontrolled factors such as EXCP's (number of I/0 starts) and core usage are included as covariates in the analysis of variance. This experiment is part of a continuing activity of Measurement, Evaluation and Simulation. It is designed to provide data for improving performance incrementally. The results of the experiment provided an optimal segment size for the given classing/scheduling algorithm and core-layout. Design objectives and details of the analysis are also presented.
Batch vs. timesharing: Closing the gap
Authors: Bruce Lakin
Venue: Proceedings of the 8th annual ACM SIGUCCS conference on User services (1980)

This paper describes and analyzes the current state of IBM timesharing. The functionality of the timesharing system is described through the evolution of the remote job processing facility. The constraints to the replacement of batch by timesharing are discussed, acknowledging that these constraints are offset by the potential of timesharing to provide an enhanced computing environment via its man-machine interface. Finally the actual implementations of common computing tasks are compared against the full potential inherent to timesharing.
Optical flow techniques applied to video coding
Authors: R. Krishnamurthy, P. Moulin, J. Woods
Venue: Proceedings of the 1995 International Conference on Image Processing (Vol. 1)-Volume 1 - Volume 1 (1995)

Motion estimation is an important part of most video coding schemes because it enables us to exploit the high degree of temporal redundancy present. Though block matching algorithms (BMA) yield coarse and piecewise-constant fields, they are very popular due to their simplicity and low bit overhead. In this paper, we propose to use a more advanced gradient-based technique to overcome the disadvantages of BMA. A dense motion field is estimated and compressed using a hierarchical finite element (HFE) representation, leading to an efficient, highly parallel, iterative, multiresolution optimization algorithm. The scheme also uses multiresolution measurements and a coarse-to-fine strategy to estimate large displacements. At comparable bit rates, the motion fields are much smoother and more natural than those produced by BMA. Coding gains of about 0.6 dB were obtained on Claire. More importantly, substantial visual improvements were obtained, mainly due to improved performance near the edges.
Topological Characteristics of Random Multihop Wireless Networks
Authors: Keqin Li
Venue: Proceedings of the 23rd International Conference on Distributed Computing Systems (2003)

Multihop wireless networks are treated as random symmetric planar point graphs, where all the nodes have the same transmission power and radius, and vertices of a graph are drawn randomly over certain geographical region. Several basic and important topological properties of random multihop wireless networks are studied, including node degree, connectivity, diameter, bisection width, and biconnectivity. It is believed that such study has very useful implication in real applications.
A note on virtual machines and software reliability
Authors: Jeffrey P. Buzen, Peter P. Chen, Robert P. Goldberg
Venue: Proceedings of the workshop on virtual computer systems (1973)

This note summarizes a paper entitled &ldquo;Virtual Machine Techniques for Improving System Reliability&rdquo; which will be presented April 30, 1973 at the IEEE Symposium on Computer Software Reliability in New York, New York. The full paper will appear in the Proceedings of the Symposium.
A workable interpreter project for a &ldquo;Structured Programming&rdquo; course
Authors: David R. Levine
Venue: Proceedings of the ninth SIGCSE technical symposium on Computer science education (1978)

Construction of a programming language interpreter has many beneficial aspects as a project for an intermediate level course. It provides a taste of the compilation process and an understanding of many issues involved in the structure and analysis of programming languages, all in a framework of an interesting, moderately large programming project. Over the past several years I have developed a workable interpreter, demanding a month or less, which successfully exhibits many important concepts. I hope that the presentation of this specific formulation, in detail, will prove of value to others. This project provides an interpreter for a simple, statement-oriented language.
A new mathematical programming time-sharing system using a precompiler and numerical derivatives
Authors: James L. Noyes
Venue: Proceedings of the 1976 annual conference (1976)

One approach for allowing a problem-oriented user to easily state and solve a given problem on a time-sharing system is by using a precompiler. The precompiler recognizes statements in a simple problem-oriented language, generating corresponding computer instructions and subprograms. These are used to define the problem and select the solution algorithms from a software library. To illustrate this approach, a simple Fortran precompiler has been implemented for the Univac which accepts mathematical programming commands (e.g. MINIMIZE:, SUBJECT TO:, etc.) and allows certain standard algorithms to be invoked. In order for this mathematical programming system to be genuinely easy to use, the required gradients and Hessians are approximated by accurate Richardson extrapolated difference schemes.
A complexity theoretic approach to randomness
Authors: Michael Sipser
Venue: Proceedings of the fifteenth annual ACM symposium on Theory of computing (1983)

We study a time bounded variant of Kolmogorov complexity. This notion, together with universal hashing, can be used to show that problems solvable probabilistically in polynomial time are all within the second level of the polynomial time hierarchy. We also discuss applications to the theory of probabilistic constructions.
Transformation techniques; constructive or destructive? (Panel Session)
Venue: Proceedings of the 4th international conference on Software engineering (1979)

R.M. Burstall: The Transformation Approach to Program Development The postulate underlying the transformation approach to program development is that programs are complicated, hard to understand and prone to errors because we want them to be efficient. The desire for efficiency saturates our programming habits, so much so that the simplest and least efficient way to write a program never even crosses our mind. In contrast mathematicians in making definitions seek clarity and what Dijkstra calls 'separation of concerns': they pay no attention to efficiency of computation. So the idea is to start with a program which does the right job but entirely sacrifices efficiency in favour of simplicity and modularity. We then transform it by correctness preserving transformations until a tolerably efficient, though less perspicuous, program is obtained. E.W. Dijkstra: Given the specifications, a text fit for &ldquo;automatic execution&rdquo; has to be composed, and it has to be proved that results satisfying the specifications correspond to that text. For the purpose of this discussion I regard that proof obligation as the core of the programming task. The idea of program transformations is to produce the desired text B not directly, but to derive it from a text A via successive transformations from a suitable repertoire, the assumption being that the text A is the easier one to design, while the text B, when viewed as a program, is the more attractive one. The correctness proof for text B then consists of (a) the correctness proof for the original program A, (b) the chain of transformations with for each transformation the verification that it has been legally applied. P. Pepper: Our trouble comes from the - apparently intrinsic - incompatibility of clearness and efficiency which forces us to change over from the easily readable to the easily executable. This means organizing the construction of software in the form of a development process gradually abandoning clarity in favour of economy. If the single steps of this process are done according to formalized rules they are called program transformations. The discovery was that they can be done even in complicated cases. A programming methodology should be applicable to all stages of such a development in a uniform way. Transformations can be used with existential quantifiers, recursive functions, variables and with goto's equally well; they harmonize particularly well with specification tools like abstract data types and characteristic predicates and give freedom for programming styles and notations.