Search

An Algebraic Circuit for a multivariate polynomial P is a computational model for constructing the polynomial P using only additions and multiplications. It is a syntactic model of computation, as opposed to the Boolean Circuit model, and hence lower bounds for this model are widely expected to be easier to prove than lower bounds for Boolean circuits. Despite this, we do not have superpolynomial lower bounds against general algebraic circuits of depth 3 (except over constant-sized finite fields) and depth 4 (over any field other than F2), while constant-depth Boolean circuit lower bounds have been known since the early 1980s. In this paper, we prove the first superpolynomial lower bounds against algebraic circuits of all constant depths over all fields of characteristic 0. We also observe that our super-polynomial lower bound for constant-depth circuits implies the first deterministic sub-exponential time algorithm for solving the Polynomial Identity Testing (PIT) problem for all small-depth circuits using the known connection between algebraic hardness and randomness. [ABSTRACT FROM AUTHOR]

The paper discusses algorithmic priority inversion in mission-critical machine inference pipelines used in modern neural-network-based perception subsystems and describes a solution to mitigate its effect. In general, priority inversion occurs in computing systems when computations that are "less important" are performed together with or ahead of those that are "more important." Significant priority inversion occurs in existing machine inference pipelines when they do not differentiate between critical and less critical data. We describe a framework to resolve this problem and demonstrate that it improves a perception system's ability to react to critical inputs, while at the same time reducing platform cost. [ABSTRACT FROM AUTHOR]

The article discusses a research paper that applies online resource allocation algorithms to refugee resettlement, aiming to improve refugees' integration into local communities and employment prospects. By utilizing concepts from algorithm design, such as balancing resource utilization and maintaining capacity for future refugees, the authors were able to enhance the employability metric for resettlement agencies like the Hebrew Immigrant Aid Society (HIAS) by approximately 10%. This research not only addresses critical societal issues but also highlights the potential of algorithms to positively impact real-world outcomes for vulnerable populations, encouraging collaboration between algorithm designers and practitioners on important societal problems.

The Burrows-Wheeler Transform (BWT) is an invertible text transformation that permutes symbols of a text according to the lexicographical order of its suffixes. BWT is the main component of popular lossless compression programs (such as bzip2) as well as recent powerful compressed indexes (such as the r-index7), central in modern bioinformatics. The compressibility of BWT is quantified by the number r of equal-letter runs in the output. Despite the practical significance of BWT, no nontrivial upper bound on r is known. By contrast, the sizes of nearly all other known compression methods have been shown to be either always within a polylog n factor (where n is the length of the text) from z, the size of Lempel--Ziv (LZ77) parsing of the text, or much larger in the worst case (by an nε factor for ε > 0). In this paper, we show that r = O (z log² n) holds for every text. This result has numerous implications for text indexing and data compression; in particular: (1) it proves that many results related to BWT automatically apply to methods based on LZ77, for example, it is possible to obtain functionality of the suffix tree in O (z polylog n) space; (2) it shows that many text processing tasks can be solved in the optimal time assuming the text is compressible using LZ77 by a sufficiently large polylog n factor; and (3) it implies the first nontrivial relation between the number of runs in the BWT of the text and of its reverse. In addition, we provide an O (z polylog n)-time algorithm converting the LZ77 parsing into the run-length compressed BWT. To achieve this, we develop several new data structures and techniques of independent interest. In particular, we define compressed string synchronizing sets (generalizing the recently introduced powerful technique of string synchronizing sets11) and show how to efficiently construct them. Next, we propose a new variant of wavelet trees for sequences of long strings, establish a nontrivial bound on their size, and describe efficient construction algorithms. Finally, we develop new indexes that can be constructed directly from the LZ77 parsing and efficiently support pattern matching queries on text substrings. [ABSTRACT FROM AUTHOR]

The article offers the author's comments on the role of experimental evidence in computer science research. According to the author, sorting algorithms were a major issue for computer scientists in the 1960s. He adds that experiments conducted on specialized data should not be accepted under any circumstances.

The article addresses the topic of algorithm design in the solid-state drive (SSD) model of computation, noting its limitations as well as its benefits. The author references an accompanying paper which addresses one shortcoming in particular -- the phenomenon of "write amplification" -- by proposing a more accurate theoretical model of SSDs that incorporates read, write and erase operations.

In this paper, we describe multi-itinerary optimization (MIO)--a novel Bing Maps service that automates the process of building itineraries for multiple agents while optimizing their routes to minimize travel time or distance. MIO can be used by organizations with a fleet of vehicles and drivers, mobile salesforce, or a team of personnel in the field, to maximize workforce efficiency. It supports a variety of constraints, such as service time windows, duration, priority, pickup and delivery dependencies, and vehicle capacity. MIO also considers traffic conditions between locations, resulting in algorithmic challenges at multiple levels (e.g., calculating time-dependent travel-time distance matrices at scale and scheduling services for multiple agents). To support an end-to-end cloud service with turnaround times of a few seconds, our algorithm design targets a sweet spot between accuracy and performance. Toward that end, we build a scalable approach based on the ALNS metaheuristic. Our experiments show that accounting for traffic significantly improves solution quality: MIO finds efficient routes that avoid late arrivals, whereas traffic-agnostic approaches result in a 15% increase in the combined travel time and the lateness of an arrival. Furthermore, our approach generates itineraries with substantially higher quality than a cutting-edge heuristic (LKH), with faster running times for large instances. [ABSTRACT FROM AUTHOR]

Recommender systems personalize content by recommending items to users. Item recommendation algorithms are evaluated by metrics that compare the positions of truly relevant items among the recommended items. To speed up the computation of metrics, recent work often uses sampled metrics where only a smaller set of random items and the relevant items are ranked. This paper investigates such sampled metrics in more detail and shows that they are inconsistent with their exact counterpart, in the sense that they do not persist relative statements, for example, recommender A is better than B, not even in expectation. Moreover, the smaller the sample size, the less difference there is between metrics, and for very small sample size, all metrics collapse to the AUC metric. We show that it is possible to improve the quality of the sampled metrics by applying a correction, obtained by minimizing different criteria. We conclude with an empirical evaluation of the naive sampled metrics and their corrected variants. To summarize, our work suggests that sampling should be avoided for metric calculation, however if an experimental study needs to sample, the proposed corrections can improve the quality of the estimate. [ABSTRACT FROM AUTHOR]

The article presents information on the publication of a book "Applied Statistics, Algorithms," relevant to statistics, by the Royal Statistical Society in cooperation with the Science Research Council's Working Party on Statistical Computing. A policy statement describing the editorial policy appears in "Applied Statistics," Vol. 1. No. 1 (1968). A support paper describing the expected contents of the external specification and making recommendation for the layout of algorithms and for programming strategy will appear in the following issue.

The article discusses the development of the algorithm known as norms to address the statistic problem known as nearest neighbor, referencing papers in the "Annual Symposium on Foundations of Computer Science" and "Proceedings of the ACM Symposium on Theory of Computing" journals. An overview of researchers' designing of normed spaces is provided. The uses of data analysis and expander graphs, including in regard to measuring the distance from data points, are discussed.

The author presents a set of puzzles involving tidy towers, a colored block stacking puzzle. First, several scenarios related to the puzzle are presented and solved. Lastly, the author presents two puzzles and information is provided for readers to submit their solutions.

Most results in the field of algorithm design are single algorithms that solve single problems. In this paper we discuss multidimensional divide-anti-conquer, an algorithmic paradigm that can be instantiated in many different ways to yield a number of algorithms and data structures for multidimensional problems. We use this paradigm to give best-known solutions to such problems as the ECDF, maximal range searching, closest pair, and all nearest neighbor problems The contributions of the paper are on two levels. On the first level are the particular algorithms and data structures given by applying the paradigm. On the second level is the more novel contribution of this paper a detailed study of an algorithmic paradigm that is specific enough to be described precisely yet general enough to solve a wide variety of problems. [ABSTRACT FROM AUTHOR]

The article focuses on how revisiting key algorithms from computing history can unlock the hidden efficiency in computer science problems. The author discusses the shortest-path problem that has been long-standing, explores the use of the Bellman-Ford algorithm, and examines the work of Aaron Bernstein, Danupon Nanongkai, and Christian Wulff-Nilsen.

The paper describes a scheme for symbolic manipulation of index expressions which arise as a by-product of the symbolic manipulation of expressions in the matrix calculi described by the authors in a previous paper. This scheme attempts program optimization by transforming the original algorithm rather than the machine code. The goal is to automatically generate code for handling the tedious address calculations necessitated by complicated data structures. The paper is therefore preoccupied with "indexing by position." The relationship of "indexing by name" and "indexing by position" is discussed. [ABSTRACT FROM AUTHOR]

A comprehensive system for transformational grammar has been designed and implemented on the IBM 360/67 computer. The system deals with the transformational model of syntax, along the lines of Chomsky's Aspects of the Theory of Syntax. The major innovations include a full, formal description of the syntax of a transformational grammar, a directed random phrase structure generator, a lexical insertion algorithm, an extended definition of analysis, and simple problem-oriented programming language in which the algorithm for application of transformations can be expressed. In this paper we present the system as a whole, first discussing the general attitudes underlying the development of the system, then outlining the system and discussing its more important special features. References are given to papers which consider some particular aspect of the system in detail. [ABSTRACT FROM AUTHOR]

Several letters to the editor and a reply are presented in response to the article "A Graph Formulation of a School Scheduling Algorithm," by A. Salazar and R. V. Oakford in the December 1974 issue of "Communications."

Presents several letters to the editor about the computing machinery. Dissatisfaction with the quality and nature of the average technical paper presented at the Joint Computer Conferences; Comment on the article "One-Pass Compilation of Arithmetic Expressions for a Parallel Processor," by Harold S. Stone; Use of a coordinate system or characteristic indices for the progress of an algorithm.

The threshold theorem is a seminal result in the field of quantum computing asserting that arbitrarily long quantum computations can be performed on a faulty quantum computer provided that the noise level is below some constant threshold. This remarkable result comes at the price of increasing the number of qubits (quantum bits) by a large factor that scales polylogarithmically with the size of the quantum computation we wish to realize. Minimizing the space overhead for fault-tolerant quantum computation is a pressing challenge that is crucial to benefit from the computational potential of quantum devices. In this paper, we study the asymptotic scaling of the space overhead needed for fault-tolerant quantum computation. We show that the polylogarithmic factor in the standard threshold theorem is in fact not needed and that there is a fault-tolerant construction that uses a number of qubits that is only a constant factor more than the number of qubits of the ideal computation. This result was conjectured by Gottesman who suggested to replace the concatenated codes from the standard threshold theorem by quantum error-correcting codes with a constant encoding rate. The main challenge was then to find an appropriate family of quantum codes together with an efficient classical decoding algorithm working even with a noisy syndrome. The efficiency constraint is crucial here: bear in mind that qubits are inherently noisy and that faults keep accumulating during the decoding process. The role of the decoder is therefore to keep the number of errors under control during the whole computation. On a technical level, our main contribution is the analysis of the small-set-flip decoding algorithm applied to the family of quantum expander codes. We show that it can be parallelized to run in constant time while correcting sufficiently many errors on both the qubits and the syndrome to keep the error under control. These tools can be seen as a quantum generalization of the bit-flip algorithm applied to the (classical) expander codes of Sipser and Spielman. [ABSTRACT FROM AUTHOR]

Memory leaks in web applications are pervasive and difficult to debug. Leaks degrade responsiveness by increasing garbage collection costs and can even lead to browser tab crashes. Previous leak detection approaches designed for conventional applications are ineffective in the browser environment. Tracking down leaks currently requires intensive manual effort by web developers, which is often unsuccessful. This paper introduces BLeak (Browser Leak debugger), the first system for automatically debugging memory leaks in web applications. BLeak’s algorithms leverage the observation that in modern web applications, users often repeatedly return to the same (approximate) visual state (e.g., the inbox view in Gmail). Sustained growth between round trips is a strong indicator of a memory leak. To use BLeak, a developer writes a short script (17–73 LOC on our benchmarks) to drive a web application in round trips to the same visual state. BLeak then automatically generates a list of leaks found along with their root causes, ranked by return on investment. Guided by BLeak, we identify and fix over 50 memory leaks in popular libraries and apps including Airbnb, AngularJS, Google Analytics, Google Maps SDK, and jQuery. BLeak’s median precision is 100%; fixing the leaks it identifies reduces heap growth by an average of 94%, saving from 0.5MB to 8MB per round trip. [ABSTRACT FROM AUTHOR]

An important problem in terrain analysis is modeling how water flows across a terrain and creates floods by filling up depressions. In this paper, we study a number of flood-risk related problems: given a terrain Σ, represented as a triangulated xy-monotone surface with n vertices, a rain distribution, and a volume of rain ψ, determine which portions of Σ are flooded. We give an overview of efficient algorithms for these problems as well as explore the efficacy and efficiency of these algorithms on real terrains. [ABSTRACT FROM AUTHOR]

This article explores the trends in computer science research in India from 2019 to 2022 based on research coming out of leading Indian technology institutes, including Chennai Mathematical Institute, Indian Institute of Science and Indian Institute of Technology Delhi. Topics include research on automata theory, formal verification, computational complexity research, and Algorithms research.

The article discusses the relationship between model counting and streaming algorithms, and it mentions the differences between the idea of efficiency for model counting and the idea of estimating the amount of distinct elements in a given data stream. Data streams and a hashing-based technique for model counting are assessed, as well as a Satisfiability problem.

This article details Charles Babbage’s theoretical computer program, the first attempt to specific how to mechanize complex algorithms with a computer, written in 1837. The article also discusses his theoretical computer, the Analytical Engine, that his program would have run on. Topics include Babbage’s first and second code tables and the design of the Analytical Engine.

The Association for Computing Machinery (ACM) Press is pleased to announce that the Collected Algorithms from ACM (CALGO) is now available on acm.org. as of February 1997. Originally established in 1960 as the Algorithms Department in CACM, and then transfered to Transactions on Mathematical Software in 1975, CALGO is a collection of heavily used algorithms, either in original form or translated into other languages. Planned enhancements include a cumulative SHAR classification index and the full CALGO library in CD-ROM. Contact address for any information regarding CALGO has been provided.

An introduction is presented in which the author discusses an article published in the journal about load balancing, matrix-vector multiplication, and their significance to machine algorithms.

This paper provides performance results using the SPERRY UNIVAC 1100 Series linear programming product FMPS to solve a set of 16 real-world linear programming problems. As such, this paper provides a data point for the actual performance of a commercial simplex algorithm on real-world linear programming problems and shows that the simplex algorithm is a linear time algorithm in actual performance. Correlations and performance relationships not previously available are also provided. [ABSTRACT FROM AUTHOR]

This paper presents a model of an I/O subsystem in which devices can be accessed from multiple CPUs and/or via alternative channel and control unit paths. The model estimates access response times, given access rates for all CPU-device combinations. Central to the model's algorithm is the estimation of the rotational position sensing (RPS) miss probabilities by means of the maximum entropy principle. [ABSTRACT FROM AUTHOR]

This paper describes a collision avoidance algorithm for planning a safe path for a polyhedral object moving among known polyhedral objects. The algorithm transforms the obstacles so that they represent the locus of forbidden positions for an arbitrary reference point on the moving object. A trajectory of this reference point which avoids all forbidden regions is free of collisions. Trajectories are found by searching a network which indicates, for each vertex in the transformed obstacles, which other vertices can be reached safely. [ABSTRACT FROM AUTHOR]

An introduction to a paper that explores joint algorithms in data processing is presented.

Affix grammars are two-level grammars which are similar to van Wijngaarden's two-level grammars used in the definition of Algol 68. Affix grammars are shown by Koster to be equal in power to van Wijngaarden grammars. They are much more suited to parsing than are the latter, however. Koster, the inventor of affix grammars, suggests a top-down scheme for parsing them, based on recursive procedures. This paper presents a bottom-up scheme for parsing them, based on an extension of Floyd Production Language (FPL). Included is an algorithm, similar to that of DeRemer's, for converting a large class of affix grammars into FPL. The paper concludes by discussing briefly the applicabilities of the conversion algorithm and affix grammars in general, and some possible extensions to Koster's definition of affix grammars. [ABSTRACT FROM AUTHOR]

In a companion paper to this, "I Methodology and Experiences," the automatic Clenshaw-Curtis quadrature scheme was described and how each quadrature formula used in the scheme requires a cosine transformation of the integrand values was shown. The high cost of these cosine transformations has been a serious drawback in using Clenshaw-Curtis quadrature. Two other problems related to the cosine transformation have also been troublesome. First, ... conventional computation of the cosine transformation by recurrence relation is numerically unstable, particularly at the low frequencies which have the largest effect upon the integral. Second, in case the automatic scheme should require refinement of the sampling, storage is required to save the integrand values after the cosine transformation is computed. This second part of the paper shows how the cosine transformation can be computed by a modification of the fast Fourier transform and all three problems overcome. The modification is also applicable in other circumstances requiring cosine or sine transformations, such as polynomial interpolation through the Chebyshev points. [ABSTRACT FROM AUTHOR]

Clenshaw-Curtis quadrature is a particularly important automatic quadrature scheme for a variety of reasons, especially the high accuracy obtained from relatively few integrand values. However, it has received little use because it requires the computation of a cosine transformation, and the arithmetic cost of this has been prohibitive. This paper is in two parts; a companion paper, "II Computing the Cosine Transformation," shows that this objection can be overcome by computing the cosine transformation by a modification of the fast Fourier transform algorithm. This first part discusses the strategy and various error estimates, and summarizes experience with a particular implementation of the scheme. [ABSTRACT FROM AUTHOR]

Conflicts in scheduling can be treated as defining an undirected linear graph independently of the relation of the activities in conflict to additional constraints of time and space. Each connected component of such a graph, which can be found by on algorithm described by Gotlieb and Corneil, corresponds to a set of events that must be scheduled at different times. [ABSTRACT FROM AUTHOR]

The article offers highlights from the research paper "Data-Driven Algorithm Design" written by Gupta and Roughgarden.

This article investigates artificial intelligence (AI) fairness in decision-making specifically examining the limitations of this process. The article discusses eight inherent limitations in AI fairness including lack of fairness in human decision-making used to train the AI model, lack of a universal fairness definition, and limited power over the complete decision-making process.

The article discusses the construction and maintenance of Big-Data analytics systems as of March 2013, focusing on machine-learning methods and statistical methods while describing the Hazy project for algorithm management. Topics include trained systems, interfaces between algorithms and systems, the GeoDeepDive application for the statistical analysis of geological research papers, and the Bismarck project for infrastructure abstractions. Data sets, probabilistic logic programming, debugging, convex programming, and scalability are mentioned.

The article discusses the interaction between computer science and game theory. A 1995 paper by E. Kalai highlighted connections between game theory and such areas as graphs, complexity in game playing, and operations research. In 2008 developments proceed along six lines of inquiry, among them compact game representations, algorithms and mechanical design, and logical considerations inherent in games. Future progress could entail ways of thinking that go beyond the role of the Nash equilibrium in game theory.

This paper presents a generalization of an old programming technique; using it, one may add and subtract numbers represented in any radix, including a mixed radix, and stored one digit per byte in bytes of sufficient size. Radix conversion is unnecessary, no looping is required, and numbers may even be stored in a display (I/O) format. Applications to Cobol, MIX, and hexadecimal sums are discussed. [ABSTRACT FROM AUTHOR]

An introduction to an article published in the journal about the topic of graph isomorphism in computer science is presented.

The use of the Kleene regular expression notation for describing algebraic language syntax, in particular of ALGOL is described in this paper. A FORTRAN II computer program for carrying out the elimination algorithm of Gorn, similar to Gaussian elimination for linear systems of algebraic equations, is described. This was applied to numerous smaller languages, including some sublanguages of ALGOL. A hand calculation result of the application of the algorithm to all of ALGOL is given, thus expressing the Revised ALGOL 1960 syntax in completely nonrecursive terms, as far as its context-free portion is concerned. This description in many ways is far more intuitively understood than the previous recursive description, it is suggested. The paper also includes results of the machine program, which does not include a simplification algorithm. [ABSTRACT FROM AUTHOR]

The article presents an introduction to a paper regarding a deterministic parallel algorithm for bipartite matching.

An introduction to an article published in the journal about signal reconstruction is presented, particularly algorithmic qualities related to what is referred to as the signal reconstruction problem (SRP).

This paper consists of three interrelated parts. In the first part forms are introduced as an. abstraction and generalization of business paper forms. A set of facilities for the manipulation of forms and their contents is Out-Lined. Forms can be created, stored, found, viewed in different media, mailed, and located by office workers. Data on forms can also be processed in a completely integrated way. The facilities are discussed both abstractly and in relation to a prototype system. In the second part a faculty is outlined for the specification and implementation of automatic form procedures. These procedures specify actions on forms which are triggered automatically when certain preconditions are met. The preconditions, actions, and specification method are based on forms. The discussion is centered on our implementation of such a specification framework. Finally, in the third part, techniques for the analysis of office flow are specified. An algorithm is outlined for the categorization of forms into classes depending on the local routing and actions on the forms. In this way, we can obtain the paths that forms take and analyze the system for correctness and loading characteristics. [ABSTRACT FROM AUTHOR]

Presents letters to the editor referencing articles and topics published in earlier issues of the journal "Communications of the ACM." Focuses on issues relating updating of master files; Information on algorithms used in updating process; Introduction on structured programming in everyday activities; Alternatives used in processing the different file records.

Time and state descriptions form the core of a simulation model representation. The historical influence of initial application areas and the exigencies of language implementations have created a muddled view of the time and state relationships. As a consequence, users of simulation programming languages work in relative isolation; model development, simulation application, model portability, and the communication of results are inhibited and simulation practice fails to contribute to the recognition of an underlying foundation or integrating structure. A model representation structure has been forged from a small set of basic definitions which carefully distinguish the state and time relationships. This paper focuses on the coordination of the time and state concepts using "object" as the link. In addition to clarifying the relationships, the structure relates the concept of ""state-sequenced simulation" to the variations in time flow mechanisms. In conclusion, some speculations are offered regarding alternative algorithms for time flow mechanisms. [ABSTRACT FROM AUTHOR]

This paper describes efficient new heuristic methods to color the vertices of a graph which rely upon the comparison of the degrees and structure of a graph. A method is developed which is exact for bipartite graphs and is an important part of heuristic procedures to find maximal cliques in general graphs. Finally an exact method is given which performs better than the Randall-Brown algorithm and is able to color larger graphs, and the new heuristic methods, the classical methods, and the exact method are compared. [ABSTRACT FROM AUTHOR]

Optimal decision table conversion has been tackled in the literature using two approaches, dynamic programming and branch-and-bound. The former technique is quite effective, but its time and space requirements are independent of how "easy" the given table is. Furthermore, it cannot be used to produce good, quasioptimal solutions. The branch-and-bound technique uses a good heuristic to direct the search, but is cluttered up by an enormous search space, since the number of solutions increases with the number of test variables according to a double exponential. In this paper we suggest a heuristically guided top-down search algorithm which, like dynamic programming, recognizes identical subproblems but which can be used to find both optimal and quasioptimal solutions. The heuristic search method introduced in this paper combines the positive aspects of the above two techniques. Compressed tables with a large number of variables can be handled without deriving expanded tables first. [ABSTRACT FROM AUTHOR]

n this paper an algorithm to detect logical errors in a limited-entry decision table and in loop-free programs with embedded decision tables is developed. All the conditions in the decision tables are assumed to be inequalities or equalities relating linear expressions. It is also assumed that actions in a decision table are linear in variables which occur in the condition stub of the decision table (or tables) to which control is transferred from the table. The algorithm is based on determining whether a set of linear inequalities has or does not have a solution. The algorithm described in the paper is implemented in Fortran IV. [ABSTRACT FROM AUTHOR]

This paper discusses the computation of matrix chain products of the form M1 X M2 X ... X Mn where Mi's are matrices. The order in which the matrices are computed affects the number of operations. A sufficient condition about the association of the matrices in the optimal order is presented. An O( n) algorithm to find an order of computation which takes less than 25 percent longer than the optimal time Topt is also presented. In most cases, the algorithm yields the optimal order or an order which takes only a few percent longer than Topt (less than I percent on the average). [ABSTRACT FROM AUTHOR]

The Alphard "form" provides the programmer with a great deal of control over the implementation of abstract data types. In this paper the abstraction techniques are extended from simple data representation and function definition to the iteration statement, the most important point of Interaction between data and the control structure of the language Itself. A means of specializing Alphard's loops to operate on abstract entities without explicit dependence on the representation of those entities is introduced. Specification and verification techniques that allow the properties of the generators for such iterations to be expressed in the form of proof rules are developed. Results are obtained that for common special cases of these loops are essentially identical to the corresponding constructs in other languages. A means of showing that a generator will terminate is also provided. [ABSTRACT FROM AUTHOR]