ppxscal/embedding_network huggingface dataset:
Shared 3D Workspaces
Authors: Joanne McGrenere, Kellogg S. Booth
Venue:  (1996)

The literature on Computer Supported Collaborative Work (CSCW) includes considerable research on 2D shared spaces and metaphors. Much less exists concerning 3D shared spaces and metaphors. This report defines terminology relevant to shared 3D workspaces, summarizes a number of areas within the literature on 2D and 3D interaction and collaboration, and identifies pertinent issues for further research. Among the issues identified are: - Can a 2D shared space metaphor be extended to 3D? - How is interaction different in 3D than in 2D? - Can metaphors for single-user 3D interaction be extended to shared 3D interaction?
A Review of ``Android Epistemology''''
Authors: I. D. Craig
Venue:  (1996)

A review of the book ``Android Epistemology'''' by Kenneth M. Ford, Clark Glymour and Patrick Hayes (MIT Press 1995), an edited version of which will appear in ``Robotika''''.
How Much Non-strictness do Lenient Programs Require?
Authors: Klaus E. Schauser, Seth C. Goldstein
Venue:  (1995)

Lenient languages, such as Id90, have been touted as among the best functional languages for massively parallel machines [ArvindHN88]. Lenient evaluation combines non-strict semantics with eager evaluation [Traub91]. Non-strictness gives these languages more expressive power than strict semantics, while eager evaluation ensures the highest degree of parallelism. Unfortunately, non-strictness incurs a large overhead, as it requires dynamic scheduling and synchronization. As a result, many powerful program analysis techniques have been developed to statically determine when non-strictness is not required [ClackP85,Traub91,Schauser94]. This paper studies a large set of lenient programs and quantifies the degree of non-strictness they require. We identify several forms of non-strictness, including functional, conditional, and data structure non-strictness. Surprisingly, most Id90 programs require neither functional nor conditional non-strictness. Many benchmark programs, however, make use of a limited form of data structure non-strictness. The paper refutes the myth that lenient programs require extensive non-strictness.
TOPOLOGY CONSTRAINED RECTILINEAR BLOCK PACKING FOR LAYOUT REUSE
Authors: Maggie Kang, Wayne W. Dai
Venue:  (1997)

As the increasing complexity of IC design, layout reuse becomes more important. The design for renewed fabrication processes usually maintains the layout technology but using different design rules. First we extract devices and group them as a set of macro device blocks. After shrinking the macro device blocks, we would like to pack the rectilinear shaped blocks together while maintaining the original topological relationship. Such problem is referred to as Topology Constrained Rectilinear Block Packing problem. In this paper, we propose an efficient data representation for a special class of rectilinear polygons, called Ordered Convex Rectilinear Polygons, using Bounded Slicing Grid (BSG) structure. Based on both Sequence Pair (SP) and BSG structure, we propose an algorithm, which independently compacts x and y dimension under the topology constraints given the blocks are ordered convex shapes. By augumenting or further partitioning the arbitrary rectilinear polygons into the ordered convex shapes, this method can be extended to handle the general rectilinear shaped blocks.
A Survey of Probability-One Homotopy Methods for EngineeringOptimization
Authors: Layne T. Watson
Venue:  (1990)

Probability-one homotopy methods are a class of algorithms for solving nonlinear systems of equations that are accurate, robust, and converge from an arbitrary starting point almost surely. These globally convergent homotopy techniques have been successfully applied to solve Brouwer fixed point problems, polynomial systems of equations, discretizations on nonlinear two-point boundary value problems based on shooting, finite differences, collocation, and finite elements, and Galerkin approximations to nonlinear partial differential equations. This paper surveys the basic theory of globally convergent probability-one homotopy algorithms relevant to optimization, describes some computer algorithms and mathematical software, and applies homotopy theory to unconstrained optimization, constrained optimization, and global optimization of polynomial programs. In addition, two realistic engineering applications (optimal design of composite laminated plates and fuel-optimal orbital satellite maneuvers) are presented.
Embedding Techniques for Distributed Dictionaries
Authors: K. Gilon, D. Peleg
Venue:  (1993)

This paper describes a number of methods for constructing a nearly-balanced binary tree and embedding it in an arbitrary given tree, with low expansion and dilation. These techniques are applicable for the efficient implementation of various distributed data structures, in particular dictionaries, via embedding suitable (centralized) tree-based data structures in the distributed network.
TIGHT WORST-CASE LOSS BOUNDS FOR PREDICTING WITH EXPERT ADVICE
Authors: David Haussler, Jyrki Kivinen, Manfred Warmuth
Venue:  (1994)

We consider on-line algorithms for predicting binary or continuous-valued outcomes, when the algorithm has available the predictions made by N experts. For a sequence of trials, we compute total losses for both the algorithm and the experts under a loss function. At the end of the trial sequence, we compare the total loss of the algorithm to the total loss of the best expert, i.e., the expert with the least loss on the particular trial sequence. We show that for a large class of loss functions, with binary outcomes the total loss of the algorithm proposed by Vovk exceeds the total loss of the best expert at most by the amount c ln N, where c is a constant determined by the loss function. This upper bound does not depend on any assumptions on how the experts'' predictions or the outcomes are generated, and the trial sequence can be arbitrarily long. We give a straightforward method for finding the correct value c and show by a lower bound that for this value of c, the upper bound is asymptotically tight. The lower bound is based on a probabilistic adversary argument. The class of loss functions for which the c ln N upper bound holds includes the square loss, the logarithmic loss, and the Hellinger loss. We also consider another class of loss functions, including the absolute loss, for which we have an Omega((l log N)^(1/2)) lower bound, where l is the number of trials. We show that for the square and logarithmic loss functions, Vovk''s algorithm achieves the same worst-case upper bounds with continuous-valued outcomes as with binary outcomes. For the absolute loss, we show how bounds earlier achieved for binary outcomes can be achieved with continuous-valued outcomes using a slightly more complicated algorithm.
Entropy and Expected Acceptance Counts for Finite Automata
Authors: Nicholas Pippenger
Venue:  (2002)

Entropy and Expected Acceptance Counts for Finite Automata Nicholas Pippenger If a sequence of independent unbiased random bits is fed into a finite automaton, it is straightforward to calculate the expected number of acceptances among the first n prefixes of the sequence. This paper deals with the situation in which the random bits are neither independent nor unbiased, but are nearly so. We show that, under suitable assumptions concerning the automaton, if the the difference between the entropy of the first n bits and n converges to a constant exponentially fast, then the change in the expected number of acceptances also converges to a constant exponentially fast. We illustrate this result with a variety of examples in which numbers following the reciprocal distribution, which governs the significands of floating-point numbers, are recoded in the execution of various multiplication algorithms.
Efficient Mapping of Software System Traces to Architectural Views
Authors: Robert J. Walker, Gail C. Murphy, Jeffrey Steinbok, Martin P. Robillard
Venue:  (2000)

Information about a software system''s execution can help a developer with many tasks, including software testing, performance tuning, and program understanding. In almost all cases, this dynamic information is reported in terms of source-level constructs, such as procedures and methods. For some software engineering tasks, source-level information is not optimal because there is a wide gap between the information presented (i.e., procedures) and the concepts of interest to the software developer (i.e., subsystems). One way to close this gap is to allow developers to investigate the execution information in terms of a higher-level, typically architectural, view. In this paper, we present a straightforward encoding technique for dynamic trace information that makes it tractable and efficient to manipulate a trace from a variety of different architecture-level viewpoints. We also describe how this encoding technique has been used to support the development of two tools: a visualization tool and a path query tool. We present this technique to enable the development of additional tools that manipulate dynamic information at a higher-level than source.
AI, Science, and Intellectual Processes: Preliminary Remarks andArguments
Authors: Jane T Nutter
Venue:  (1990)

This paper argues that trying to answer questions like the precise relationship of AI to existing disciplines (psychology, philosophy, linguistics, etc.) is both premature and potentially harmful to all concerned. This is not to say that we cannot say anything useful on the underlying questions which plague those who question its status; but the answers that can currently be given will probably fail to satisfy critics and proponents alike. This dissatisfaction--and indeed much of the debate--results from a view of science which takes as its model mature, developed sciences, and ignores facts about necessary phases in their development. This paper also argues that the question whether AI is a science is usually standing surrogate for concerns that have nothing whatever to do with science, and which should be addressed on their own grounds. The fundamental thesis here is that understanding the current status of AI, and so understanding the relationship between the various proposed approaches, requires adopting a more sophisticated approach to the status and development of intellectual disciplines, and that such an approach can contribute substantially to a broad area of current disputes, including most notably the "traditionalist/connectionist" controversy. This paper is divided into four questions: (1) "What is AI?"; (2) "Is AI science?"; (3) "What does all this say about AI, cognitive science and art forms?" The discussion of the fourth question will deal with consequences concerning the relationship between "traditional" and connectionist AI. I outline my positions on these four questions.
Formalizing Non-Monotonic Reasoning Systems
Authors: David W. Etherington
Venue:  (1983)

In recent years, there has been considerable interest in non-monotonic reasoning systems. Unfortunately, formal rigor has not always kept pace with the enthusiastic propagation of new systems. Formalizing such systems may yield dividends in terms of both clarity and correctness. We show that Default Logic is a useful tool for the specification and description of non-monotonic systems, and present new results which enhance this usefulness.
Verifying Tomasulo''s Algorithm by Refinement
Authors: T. Arons, A. Pnueli
Venue:  (1998)

In this paper Tomasulo''s algorithm for out-of-order execution is shown to be a refinement of the sequential instruction execution algorithm. Correctness of Tomasulo''s algorithm is shown by proving that the register files of Tomasulo''s algorithm and the sequential algorithm agree once all instructions have been completed.
An Interactive Simulation Description Interpreter
Authors: Robert M. O''Keefe
Venue:  (1986)

Inter_Sim, an interactive tool for developing and running discrete simulation models by interpreting a descriptive language, is presented. A running simulation, when halted, remains suspended. Aftern extension, alteration, or investigation of the description, the simulation runs from the suspended state. Thus the user views the simulation model as a running model, rather than a piece of static text. The strengths and weaknesses of such an approach are discussed; other methods of interactive development are reviewed.
Semantics-based Failure Recovery in Distributed Systems with Optimistic Message Logging
Authors: H. Leong, D. Agrawal
Venue:  (1995)

Recovery from failures is important in distrinuted computing. A common technique to support recovery is asynchronous checkpointing, coupled with optimistic message logging. These schemes have low overheads during failure-free operations and can provide an acceptable degree of fault-tolerance. Central to these protocols is the determination of a maximal consistent global state, which is recoverable. Message semantics is not exploited in most existing recovery protocols to determine the recoverable state. We propose to identify messages that are not influential in the computation through message semantics. These messages can be logically removed from the computation without changing its meaning or result. In this paper, we illustrate with examples how the removal of these messages improves the theoretical maximal consistent global state. Taking semantics into account, recovery protocols are then developed to realize the idea. The semantics in object-oriented databases is adapted to special processes acting as servers for further improvements. This technique can also be applied to ensure a more timely committment for output in a distributed computation.
Investigating Termination in Active Database Systems with ExpressiveRule Languages
Authors: Anca Vaduva, Stella Gatziu, Klaus R. Dittrich
Venue:  (1997)

The powerful functionality that active mechanisms add to database management systems presents, besides many advantages, a number of problems related to the control of their behavior. This paper deals with one of these problems: the termination of rule execution. We explain the termination aspect and the aim of termination analysis. Then, we present our approach for investigating the termination of rule execution. In contrast to others, this approach also addresses expressive rule languages as they have been proposed for various recent active database management system prototypes.
Mediators in a Radiation Treatment Planning Environment
Authors: Kevin J. Sullivan, Ira J. Kalet, David Notkin
Venue:  (1995)

We describe the architecture of Prism, an integrated system for planning radiation treatments for cancer patients. This architecture is based on the mediator design approach. The problem addressed by this approach is that common methods of designing integrated systems lead to undue module coupling, significantly complicating software development and evolution. The mediator approach was devised to ameliorate the conflict between integration and ease of software development and evolution. It does this by enabling the composition of visible and independently defined components into behaviorally integrated systems. We present Prism as evidence for two claims: first, the mediator method can overcome the problem of coupling, easing the design and evolution of real integrated systems; second, the method profitably can be learned and used by practicing software engineers. Prism continues to evolve in clinical use at University of Washington and Emory University Cancer Centers, and in trials at other institutions, including the University of Miami. It is an attractive subject for continuing research on integration, software structure, and the evolution of mediator-based architectures.
Sequential Regularization Methods for Nonlinear Higher Index DAE''s
Authors: Uri M. Ascher, Ping Lin
Venue:  (1995)

Sequential regularization methods relate to a combination of stabilization methods and the usual penalty method for differential equations with algebraic equality constraints. The present paper extends an earlier work \cite{al} to nonlinear problems and to DAEs with index higher than 2. Rather than having one ``winning'''' method, this is a class of methods from which a number of variants are singled out as being particularly effective methods in certain circumstances. We propose sequential regularization methods for index-2 and index-3 DAEs, both with and without constraint singularities. In the case of no constraint singularity we prove convergence results. Numerical experiments confirm our theoretical predictions and demonstrate the viability of the proposed methods. The examples include constrained multibody systems.
On Security Preserving Reductions - Revised Terminology
Authors: O. Goldreich
Venue:  (2000)

Many of the results in Modern Cryptography are actually transformations of a basic computational phenomenon (i.e., a basic primitive, tool or assumption) to a more complex phenomenon (i.e., a higher level primitive or application). The transformation is explicit and is always accompanied by an explicit reduction of the violation of the security of the former phenomenon to the violation of the latter. A key aspect is the efficiency of the reduction. We discuss and slightly modify the hierarchy of reductions originally suggested by Levin. The ACM Portal is published by the Association for Computing Machinery. Copyright © 2010 ACM, Inc. Terms of Usage Privacy Policy Code of Ethics Contact Us Useful downloads: Adobe Acrobat QuickTime Windows Media Player Real Player
Lock Coarsening: Eliminating Lock Overhead in Automatically Parallelized Object-Based Programs
Authors: Pedro Diniz, Martin Rinard
Venue:  (1996)

Atomic operations are a key primitive in parallel computing systems. The standard implementation mechanism for atomic operations uses mutual exclusion locks. In an object-based programming system the natural granularity is to give each object its own lock. Each operation can then make its execution atomic by acquiring and releasing the lock for the object that it accesses. But this fine lock granularity may have high synchronization overhead because it maximizes the number of executed acquire and release constructs. To achieve good performance it may be necessary to reduce the overhead by coarsening the granularity at which the computation locks objects. In this paper we describe a static analysis technique --- lock coarsening --- designed to automatically increase the lock granularity in object-based programs with atomic operations. We have implemented this technique in the context of a parallelizing compiler for irregular, object-based programs and used it to improve the generated parallel code. Experiments with two automatically parallelized applications show these algorithms to be effective in reducing the lock overhead to negligible levels.
ARIES: A REARRANGEABLE INEXPENSIVE EDGE-BASED ON-LINE STEINER ALGORITHM
Authors: Fred Bauer, Anujan Varma
Venue:  (1995)

In this paper, we propose and evaluate ARIES, a heuristic for updating multicast trees dynamically in large point-to-point networks. The algorithm is based on monitoring the accumulated damage to the multicast tree within local regions of the tree as nodes are added and deleted, and triggering a rearrangement when the number of changes within a connected subtree crosses a set threshold. We derive an analytical upper-bound on the competitiveness of the algorithm. We also present simulation results to compare the average-case performance of the algorithm with two other known algorithms for the dynamic multicast problem, GREEDY and EBA (Edge-Bounded Algorithm). Our results show that ARIES provides the best balance among competitiveness, computational effort, and changes in the multicast tree after each update.
A Generalized Comparison of Quadtree and Bintree Storage Requirements
Authors: Clifford A. Shaffer, Ramana Juvvadi, Lenwood S. Heath
Venue:  (1989)

The quadtree and bintree data structures are two variants on the principle of hierarchical regular decomposition applied to image representation. A comparison of the storage requirements for images represented by these two methods is presented. The relative storage efficiency of quadtrees and bintrees is determined by two factors: the relative mode size for the two representations as determined by the data structure implementation, and the number of quadtree leaf node pairs that merge to form a single leaf node after conversion to the bintree representation. The merging probability is analyzed, and found to be close to 0.5 for most images. The resulting storage efficiency for a number for representative implementations is discussed. Each of the data structures has implementations (and associated applications) for which it is more space efficient.
Indiana university's enterprise portal as a service delivery framework
Authors: James Thomas
Venue: Designing portals: opportunities and challenges (2003)

Indiana University has embarked on a journey to create an enterprise portal, a place to which faculty, staff, students, alumni, prospective students and others will travel to uncover a broad array of dynamic Web services. "OneStart" (http://onestart.iu.edu) provides a compelling place for faculty, staff and students to find services with the intent of developing lifelong campus citizens of IU. Indiana University is a large and complex institution consisting of eight campuses, over 92,000 students and 445,000 alumni. Developing one enterprise portal for the entire institution presents tremendous challenges. IU's portal strategy hinges on the ability to provide a "service delivery framework." This framework provides single sign-on, customization, personalization and workflow. By making use of component based design methodologies, the framework also provides a flexible publishing environment allowing services to be created by different Web development teams across all IU campuses. This chapter describes the motivation and strategy behind the creation of OneStart, the enterprise portal service delivery framework at Indiana University.
Ustat -- A Real-time Intrusion Detection System for UNIX
Authors: Koral Ilgun
Venue:  (1993)

This thesis presents the design and implementation of a real-time intrusion detection tool, referred to as Ustat, State Transition Analysis Tool for UNIX. The original design was first developed by Phillip A. Porras and presented in [Porr91 ] as STAT, State Transition Analysis Tool. STAT is a new model for representing computer penetrations, and applied the model to the development of a real-time intrusion detection tool. In STAT, a penetration is identified as a sequence of state changes that lead the computer system from some initial state to a target compromised state. The author of this document has developed the first prototype, Ustat, for UNIX, in particular for SunOS 4.1.1. Ustat makes use of the audit trails that are collected by the C2 Basic Security Module of SunOS and it keeps track of only those critical actions that must occur for the successful completion of the penetration. This approach differs from other rule-based penetration identification tools that pattern match sequences of audit records.
VOSS - A Formal Hardware Verification System User''s Guide
Authors: Carl Seger
Venue:  (1993)

The Voss system is a formal verification system aimed primarily at hardware verification. In particular, verification using symbolic trajectory evaluation is strongly supported. The Voss system consists of a set of programs. The main one is called fl and is the core of the verification system. Since the metalanguage in fl is a fully general functional language in which Ordered Binary Decision Diagrams (OBDDs) have been built in, the verification system is not only useful for carrying out trajectory evaluation, but also for experimenting with various verification (formal and informal) techniques that require the use of OBDDs. This document is intended as both a user''s guide and (to some extent) a reference guide. For the Voss alpha release, this document is still quite incomplete, but work is underway to remedy this.