Showing papers in "Sigact News in 1992"

Linear logic

Abstract: Linear logic was introduced by Girard in 1987 [11] . Since then many results have supported Girard' s statement, \"Linear logic is a resource conscious logic,\" and related slogans . Increasingly, computer scientists have come to recognize linear logic as an expressive and powerful logic with connection s to a variety of topics in computer science . This column presents a.n intuitive overview of linear logic, some recent theoretical results, an d summarizes several applications of linear logic to computer science . Other introductions to linear logic may be found in [12, 361 .

Book Review: Introduction to Parallel Algorithms and Architectures : Arrays, Trees, Hypercubes by F. T. Leighton (Morgan Kauffman Pub, 1992)

Abstract: In the ever-expanding field of parallel computing, we have seen a number of textbooks , some emphasizing the design aspects of parallel algorithms based on abstract models of paralle l machines (such as PRAMs) and some others focusing on the topological properties of paralle l architectures . What is needed in this area is a book which provides a linkage between th e topological properties of a parallel network and its computational capabilities or limitations , as well as comparative analyses of parallel architectures, not only among the proposed ones but also in view of a desirable general-purpose parallel machine which is yet to be built . The book under review comes closest to this goal . The author, a well-known researcher in paralle l computing, once again has proved his expertise and authority on the materials covered . This book will certainly have an impact to the psychology of students and researchers alike, on ho w to correlate parallel architectures and algorithms . Physically, this book is organized around three categories of parallel architectures : Arrays and Trees, Meshes of Trees, and Hypercubic networks . Each category covers not only th e basic type of architectures but also other variants or related models . For example, Chapter 1 on Arrays and Trees encompasses linear arrays, two-dimensional arrays, trees, ring, torus, X tree, pyramid, multigrid networks, systolic and semisystolic networks, and higher-dimensional arrays as well . Similarly, Chapter 2 on Meshes of Trees shows different ways of looking at two-dimensional meshes of trees at the beginning and further extends to higher-dimensiona l meshes of trees, and shuffle-tree graphs at the end . The third chapter, Hypercubes and Related Networks, covers butterfly, cube-connected-cycles, Benes network, shuffle-exchange, de Bruij n network, butterfly-like networks (Omega network, flip network, baseline and reverse baselin e networks, Banyan and delta networks, and k-ary butterfy), and de Bruijn-type networks (k-ar y de Bruijn network, and generalized shuffle-exchange network) . Whereas the above parallel networks constitute the architectural domain of the hook as th e basis, the application domain — parallel computation problems and algorithms — threads th e chapters together and helps a reader to view the similarities and differences of each network , from algorithm design standpoint . In addition to the definitions and characterizations of th e topological properties of the parallel architectures, each chapter examines a carefully-chose n subset of fundamental computational problems such as integer arithmetic, prefix computation , list ranking, sorting and counting, matrix arithmetic, graph problems, Fast Fourier Transfor m and Discrete Fourier Transform, computational geometry, and image analysis etc . The solution s to these problems are explored from simple algorithms to more complicated ones until it achieve s optimality. This approach seems to be adequate to reveal the capability and limitations of eac h network . The problems and algorithms are not treated in an isolated context but provokes a reader to capture what is achievable in terms of speedup and efficiency, and what is the limi t in terms of lower hounds, in a particular parallel network under focus . The author pays special attention to the routing problem . Considering that routing is a common vehicle for solving most of the regular and irregular parallel computation problem s in a fixed-connection network, the general capability of each network against an abstract parallel machine model is properly exposed via routing problem . Also discussed are the containment/embedding of one network in another, i .e . mapping between networks and the simulatio n

Animating algorithms with XTANGO

Abstract: Algorithm animation is the process of abstracting a program 's data, operations, and semantics, and then creating a dynamic visualization of those abstractions[3] . Algorithm animations can be helpful for teaching algorithms and as a research test-bed for acquirin g intuition about the fundamental behavior of algorithms . XTANGO is a general purpos e algorithm animation system that I have developed . The system supports the development of color, real-time, 2 & 1/2-dimensional, smooth algorithm animations . The focus of the syste m is on ease-of-use ; programmers need not be graphics experts to develop their own animations . Many students, both undergraduates and graduates, have used XTANGO to create algorithm animations . Information about how to acquire XTANGO free via anonymous ftp is include d later in this article . The basic process of building an algorithm animation consists of implementing the algorithm in C (another language can be used, but it must just produce a trace file whic h is read by a C program driver) and then deciding on the important events or operation s to be portrayed during the execution of the algorithm . These events activate animatio n routines implemented in a separate file using the XTANGO animation package to creat e and manipulate objects (circles, squares, lines, and so on) . Transitions on objects include movement, color change, resizing, and filling, as well as others . For example, the animatio n of binary search consists of a series of rectangles, each representing one of the elements bein g searched . A bouncing circle hits the current dividing element, which changes color . The bal l then bounces to the next dividing element and continues to do this until the desired elemen t has been found . The function call to activate a given animation routine or routines is placed in the pro gram at the point where the event occurs . In the above example, the call to the routine t o bounce the circle to the chosen element would be placed after the code in the implementatio n where the pertinent element was chosen . This method has several advantages . First, the algorithm implementation can be debugged separately from the animation . Second, because the animation is produced and appears on the screen as the algorithm executes, viewing animations over different data sets is as easy as running the algorithm again . No recompilation is necessary . XTANGO provides a high-level animation package for creating algorithm animations , rather than forcing developers to make calls to a low-level library such as as Xlib . The package is based on the path-transition animation paradigm[2] which provides four abstract dat a types, images, locations, paths and transitions, to describe an animation . Animation de signers create images (graphical objects) to model the data or attributes of their algorithms .

The p-shovelers problem: (computing with time-varying data)

Abstract: In a winter morning one man shovels the snow from his driveway. When the job is finished he can get out with the car. In the neighbouring driveway p men remove the same amount of snow in one p-th of time. The next morning is snowy. As the single shoveler goes on, new snow falls making his job harder. The neighbouring shovelers work for a shorter time, and a smaller amount of snow falls meanwhile, so that they clean the driveway in less than one p-th of time. This seems to conflict with a folklore theorem on parallel speed-up.

How reductions to sparse sets collapse the polynomial-time hierarchy: a primer: Part II restricted polynomial-time reductions

Abstract: It has long been known that if SAT is reducible to a sparse set by more restrictive polynomial time reductions, then even more dramatic collapses of the polynomial-time hierarchy must occur . Recently, ([OW-91]), Ogiwara and Watanabe proved that if SAT <1tt S for some sparse set S, then P = NP, a result which subsumed all earlier results on polynomial-time bounded-truth-table an d many-one reductions of SAT to sparse sets .

A bound on the shift function in terms of the Busy Beaver function

Abstract: The Busy Beaver function Σ(n) is the maximum number of 1's a halting n-state Turing machine may leave on an initially blank tape. The shift function S(n) is the maximum number of moves such a machine may make before it halts. This paper shows that S(n)

Randomized algorithms in “primitive” cultures or what is the oracle complexity of a dead chicken?

Abstract: Newton said, “If I have seen further it is by standing upon the shoulders of Giants.” But too often in the theoretical computer science community, we see ourselves as pioneers, covering untrod territory, without realizing that others may have gone before us. It is my point in this note to kneel down for a moment in the wilderness of discovery, and note the outlines of ancient foundations buried under our frontier outpost. I will show that some of the concepts of randomized algorithms can quite legitimately be said to have their origins in the beliefs of two “primitive” societies: namely, the Naskapi and the Azande. Randomized algorithms are of great interest in theoretical computer science. Although some of the basic ideas can be traced back as far as Laplace’s 1812 analysis of the Buffon needle problem [6] and Lord Kelvin’s randomized simulation techniques [5], they did not gain wide acceptance until the papers of Solovay and Strassen [9], Rabin [8], and the thesis of Gill [4].

Computational geometry

Abstract: The class of n2-hard geometric problems is described, with special concentration on detecting collinearities among a set of points in the plane.

Undaunted sets (extended abstract)

Abstract: Recently, there has been a great surge of interest in set theory . Space doesn 't permit us t o give a thorough overview but the following citations must be made . A remarkable invention of Parikh, modestly called \"dumb-founded sets, \" is receiving considerable attention, especiall y in the logic of political sciences . Similarly, by now everybody knows that the \" situations \" of Barwise and Perry would be in real trouble were it not for the strong assistance of Aczel ' s non-well-founded sets or hypersets, as they are commonly known . Encouraged by all these, we have come up with a. new flavor of sets which we choose t o call \"undaunted sets \" (UND) . Our sets are undaunted in a rather strong sense, viz . they can model anything and everything ; they are neither discouraged nor dismayed by the difficult y of the task at hand . (Aside : In fact, an anonymous reviewer of this short note reported tha t he has found an ingenious way of solving the \"Yale Shooting Problem \" via. UND . He hopes to report this result in the next IJCAI . ) All this is not without a price though . In order to achieve this universality, we had t o unify the theories of Parikh and Aczel, with some technical assistance from KPU (also know n as Kripke's Plateau of Unknown) along the way . And boy, was that exciting! (Details to b e reported in the full version of this paper . . . ) What is an undaunted set? Well, we have a FOCS (and another STOC) paper in progress , which makes this notion very precise but the reader will have to be content with the followin g taste of the real thing . An undaunted set is a. situation which can answer any membershi p question . How does that work? Easy : a situation is, as you well know, a limited portion of the reality that you can \"individuate .\" Thus, it is able to tell you what it includes a s members. However, since a situation is also a dumb-founded set (a fact . which Parikh seem s

The Turing machine of Ackermann's function

Abstract: 211( x , y ) = x + y ; 2t„+i( x , 1 ) = x ; 2t,l+i( x , y + 1 ) = Zan{ x , 2tn-f-1( x > y ) } although of more potent growth than any primitive recursive function, is nonetheless de fined effectively by double recursion, and so Qt E 7., the (non-constructive) class of genera l recursive functions . Therefore, since any f E R has among its equivalent formulations , representability in first-order arithmetic, and computability by a TURING machine (o r flow-chart), it may be of interest to the reader to see that the flow-chart of 2t is easily given . To complement this, the feather diagram of the calculation of %,,, (x, y) is sketched, with application to a characterization of 2i due to G . MILLS .