Arrow Research search

Author name cluster

Uzi Vishkin

Possible papers associated with this exact author name in Arrow. This page groups case-insensitive exact name matches and is not a full identity disambiguation profile.

36 papers
2 author rows

Possible papers

36

NeurIPS Conference 2021 Conference Paper

Can You Learn an Algorithm? Generalizing from Easy to Hard Problems with Recurrent Networks

  • Avi Schwarzschild
  • Eitan Borgnia
  • Arjun Gupta
  • Furong Huang
  • Uzi Vishkin
  • Micah Goldblum
  • Tom Goldstein

Deep neural networks are powerful machines for visual pattern recognition, but reasoning tasks that are easy for humans may still be difficult for neural models. Humans possess the ability to extrapolate reasoning strategies learned on simple problems to solve harder examples, often by thinking for longer. For example, a person who has learned to solve small mazes can easily extend the very same search techniques to solve much larger mazes by spending more time. In computers, this behavior is often achieved through the use of algorithms, which scale to arbitrarily hard problem instances at the cost of more computation. In contrast, the sequential computing budget of feed-forward neural networks is limited by their depth, and networks trained on simple problems have no way of extending their reasoning to accommodate harder problems. In this work, we show that recurrent networks trained to solve simple problems with few recurrent steps can indeed solve much more complex problems simply by performing additional recurrences during inference. We demonstrate this algorithmic behavior of recurrent networks on prefix sum computation, mazes, and chess. In all three domains, networks trained on simple problem instances are able to extend their reasoning abilities at test time simply by "thinking for longer. "

TCS Journal 2014 Journal Article

Parallel algorithms for Burrows–Wheeler compression and decompression

  • James A. Edwards
  • Uzi Vishkin

We present work-optimal PRAM algorithms for Burrows–Wheeler compression and decompression of strings over a constant alphabet. For a string of length n, the depth of the compression algorithm is O ( log 2 n ), and the depth of the corresponding decompression algorithm is O ( log n ). These appear to be the first polylogarithmic-time work-optimal parallel algorithms for any standard lossless compression scheme. The algorithms for the individual stages of compression and decompression may also be of independent interest: (1) a novel O ( log n ) -time, O ( n ) -work PRAM algorithm for Huffman decoding; (2) original insights into the stages of the BW compression and decompression problems, bringing out parallelism that was not readily apparent, allowing them to be mapped to elementary parallel routines that have O ( log n ) -time, O ( n ) -work solutions, such as: (i) prefix-sums problems with an appropriately-defined associative binary operator for several stages, and (ii) list ranking for the final stage of decompression. Follow-up empirical work suggests potential for considerable practical speedups on a PRAM-driven many-core architecture, against a backdrop of negative contemporary results on common commercial platforms.

MFCS Conference 2004 Invited Paper

PRAM-On-Chip: A Quest for Not-So-Obvious Non-obviousness

  • Uzi Vishkin

Abstract Consider situations where once you were told about a new technical idea you reacted by saying: “but this is so obvious, I wonder how I missed it”. I found out recently that the US patent law has a nice formal way of characterizing such a situation. The US patent law protects inventions that meet three requirements: utility, novelty and non-obviousness. Non-obviousness is considered the most challenging of the three to establish. The talk will try to argue that a possible virtue for a technical contribution is when, in restrospect, its non-obviousness is not too obvious; and since hindsight is always 20/20, one may often need to resort to various types of circumstantial evidence in order to establish non-obviousness. There are two reasons for bringing this issue up in my talk: (i) seeking such a virtue has been an objective of my work over the years, and (ii) issues of taste in research are more legitimate for invited talks; there might be merit in reminding younger researchers that not every “result” is necessarily also a “contribution”; perhaps the criterion of not-so-obvious non-obviousness could be helpful in some cases to help recognize a contribution. The focus of the second focal point for my talk, the PRAM-On-Chip approach, meets at least one of the standard legal ways to support non-obviousness: “Expressions of disbelief by experts constitute strong evidence of non-obviousness”. It is well documented that the whole PRAM algorithmic theory was considered “unrealistic” by numerous experts in the field, prior to the PRAM-On-Chip project. In fact, I needed recently to use this documentation in a reply to the U. S. patent office. An introduction of the PRAM-On-Chip approach follows. Many parallel computer systems architectures have been proposed and built over the last several decades. The outreach of the few that survived has been severely limited due to their programmability problems. The question of how to think algorithmically in parallel has been the fundamental problem for which these architectures did not have an adequate answer. A computational model, the Parallel Random Access Model (PRAM), has been developed by numerous (theoretical computer science) algorithm researchers to address this question during the 1980s and 1990s and is considered by many as the easiest known approach to parallel programming. Despite the broad interest the PRAM generated, it had not been possible to build parallel machines that adequately support it using multi-chip multiprocessors, the only multiprocessors that were buildable in the 1990s since low-overhead coordination was not possible. Our main insight is that this is becoming possible with the increasing amounts of hardware that can be placed on a single chip. From the PRAM, as a starting point, a highly parallel explicit multi-threaded (XMT) on-chip processor architecture that relies on new low-overhead coordination mechanisms and whose performance objective is reducing single task completion time has been conceived and developed. Simulated program executions have shown dramatic performance gains over conventional processor architectures. Namely, in addition to the unique parallel programmability features, which set XMT apart from any other current approach, XMT also provides very competitive performance. If XMT will meet expectations, its introduction would greatly enhance the normal rate of improvement of conventional processor architectures leading to new applications.

FOCS Conference 1996 Conference Paper

Efficient Approximate and Dynamic Matching of Patterns Using a Labeling Paradigm (extended abstract)

  • Süleyman Cenk Sahinalp
  • Uzi Vishkin

A key approach in string processing algorithmics has been the labeling paradigm which is based on assigning labels to some of the substrings of a given string. If these labels are chosen consistently, they can enable fast comparisons of substrings. Until the first optimal parallel algorithm for suffix tree construction was given by the authors in 1994 the labeling paradigm was considered not to be competitive with other approaches. They show that this general method is also useful for several central problems in the area of string processing: approximate string matching, dynamic dictionary matching, and dynamic text indexing. The approximate string matching problem deals with finding all substrings of a text which match a pattern "approximately", i. e. , with at most m differences. The differences can be in the form of inserted, deleted, or replaced characters. The text indexing problem deals with finding all occurrences of a pattern in a text, after the text is preprocessed. In the dynamic text indexing problem, updates to the text in the form of insertions and deletions of substrings are permitted. The dictionary matching problem deals with finding all occurrences of each pattern set of a set of patterns in a text, after the pattern set is preprocessed. In the dynamic dictionary matching problem, insertions and deletions of patterns to the pattern set are permitted.

TCS Journal 1996 Journal Article

Sorting strings and constructing digital search trees in parallel

  • Joseph F. Jájá
  • Kwan Woo Ryu
  • Uzi Vishkin

We describe two simple optimal-work parallel algorithms for sorting a list L= (X 1, X 2, …, X m ) of m strings over an arbitrary alphabet Σ, where ∑i = 1 m¦Xi¦ = n and two elements of Σ can be compared in unit time using a single processor. The first algorithm is a deterministic algorithm that runs in O(log 2 m/log log m) time and the second is a randomized algorithm that runs in O(logm) time. Both algorithms use O(m log m + n) operations. Compared to the best-known parallel algorithms for sorting strings, our algorithms offer the following improvements. 1. 1. The total number of operations used by our algorithms is optimal while all previous parallel algorithms use a nonoptimal number of operations. 2. 2. We make no assumption about the alphabet while the previous algorithms assume that the alphabet is restricted to {1, 2, …, n o(1)}. 3. 3. The computation model assumed by our algorithms is the Common CRCW PRAM unlike the known algorithms that assume the Arbitrary CRCW PRAM. 4. 4. Our algorithms use O(m log m + n) space, while the previous parallel algorithms use O(n 1 + ε ) space, where ε is a positive constant. We also present optimal-work parallel algorithms to construct a digital search tree for a given set of strings and to search for a string in a sorted list of strings. We use our parallel sorting algorithms to solve the problem of determining a minimal starting point of a circular string with respect to lexicographic ordering. Our solution improves upon the previous best-known result to solve this problem.

STOC Conference 1992 Conference Paper

Biconnectivity Approximations and Graph Carvings

  • Samir Khuller
  • Uzi Vishkin

A spanning tree in a graph is the smallest connected spanning subgraph. Given a graph, how does one find the smallest (i.e., least number of edges) 2-connected spanning subgraph (connectivity refers to both edge and vertex connectivity, if not specified)? Unfortunately, the problem is known to be NP -hard. We consider the problem of finding an approximation to the smallest 2-connected subgraph, by an efficient algorithm. For 2-edge connectivity our algorithm guarantees a solution that is no more than 3/2 times the optimal. For 2-vertex connectivity our algorithm guarantees a solution that is no more than 5/3 times the optimal. The previous best approximation factor is 2 for each of these problems. The new algorithms (and their analyses) depend upon a structure called a carving of a graph, which is of independent interest. We show that approximating the optimal solution to within an additive constant is NP -hard as well. We also consider the case where the graph has edge weights. We show that an approximation factor of 2 is possible in polynomial time for finding a k -edge connected spanning subgraph. This improves an approximation factor of 3 for k =2 due to [FJ81], and extends it for any k (with an increased running time though).

MFCS Conference 1992 Invited Paper

Methods in Parallel Algorithmics (Abstract)

  • Uzi Vishkin

Abstract The first half of the talk is a general introduction which emphasizes the central role that the PRAM model of parallel computation plays in algorithmic studies for parallel computers. Some of the collective knowledge-base on non-numerical parallel algorithms can be characterized in a structural way. Each structure relates a few problems and technique to one another from the basic to the more involved. The second half of the talk will: (1) overview several of these structures; and (2) zoom in on some methods.

I&C Journal 1991 Journal Article

Approximate parallel scheduling. II. Applications to logarithmic-time optimal parallel graph algorithms

  • Richard Cole
  • Uzi Vishkin

Part I of this paper presented a novel technique for approximate parallel scheduling and a new logarithmic time optimal parallel algorithm for the list ranking problem. In this part, we give a new logarithmic time parallel (PRAM) algorithm for computing the connected components of undirected graphs which uses this scheduling technique. The connectivity algorithm is optimal unless m = o(n log ∗ n) in graphs of n vertices and m edges. (log(k) denotes the kth iterate of the log function and log ∗ n denotes the least i such that log(i) n ≤ 2). Using known results, this new algorithm implies logarithmic time optimal parallel algorithms for a number of other graph problems, including biconnectivity, Euler tours, strong orientation and st-numbering. Another contribution of the present paper is a parallel union/find algorithm.

FOCS Conference 1991 Conference Paper

Towards a Theory of Nearly Constant Time Parallel Algorithms

  • Joseph Gil
  • Yossi Matias
  • Uzi Vishkin

It is demonstrated that randomization is an extremely powerful tool for designing very fast and efficient parallel algorithms. Specifically, a running time of O(lg* n) (nearly-constant), with high probability, is achieved using n/lg* n (optimal speedup) processors for a wide range of fundamental problems. Also given is a constant time algorithm which, using n processors, approximates the sum of n positive numbers to within an error which is smaller than the sum by an order of magnitude. A variety of known and new techniques are used. New techniques, which are of independent interest, include estimation of the size of a set in constant time for several settings, and ways for deriving superfast optimal algorithms from superfast nonoptimal ones. >

FOCS Conference 1990 Conference Paper

Some Triply-Logarithmic Parallel Algorithms (Extended Abstract)

  • Omer Berkman
  • Joseph F. JáJá
  • Sridhar Krishnamurthy
  • Ramakrishna Thurimella
  • Uzi Vishkin

It is established that several natural problems have triply logarithmic, or even faster, optimal parallel algorithms. These problems include: merging two sorted lists, where the values are drawn from a large, but restricted, domain on a CREW PRAM; finding all prefix minima, where the values are drawn from a restricted domain; and top-bottom global routing around a rectangle, a well-investigated problem in VLSI routing for which only highly involved serial algorithms were known. >

I&C Journal 1989 Journal Article

Faster optimal parallel prefix sums and list ranking

  • Richard Cole
  • Uzi Vishkin

We present a parallel algorithm for the prefix sums problem which runs in timeO( logn/log logn) usingnlog logn/lognprocessors (optimal speedup). This algorithm leads to a parallel list ranking algorithm which runs inO(logn) time usingn/lognprocessors (optimal speedup).

FOCS Conference 1989 Conference Paper

Recursive *-Tree Parallel Data-Structure (Extended Abstract)

  • Omer Berkman
  • Uzi Vishkin

The authors introduce a fundamentally novel parallel data structure, called recursive *-tree (star tree). For its definition, they use a generalization of this * functional and apply it to functions other than log. Using recursion in the spirit of the inverse-Akermann function, they derive recursive *-trees. The recursive *-tree data structure leads to a new design paradigm for parallel algorithms. The paradigm allows for unusually fast parallel computations that need only constant time, using an optimal number of processors under the assumption that a very small number of processors can write simultaneously, each into different bits of the same word. >

TCS Journal 1988 Journal Article

Matching patterns in strings subject to multi-linear transformations

  • Tali Eilam-Tzoreff
  • Uzi Vishkin

Suppose we are given two strings of real numbers. The longer string is called text and the other is called pattern. We consider problems within the following framework. Suppose each symbol of the pattern was modified by any transformation which is a member in some family of transformations. Find all occurences of the pattern in the text where the pattern may appear subject to any one of these transformations. Problems are introduced and efficient algorithms are given.

TCS Journal 1988 Journal Article

On finding a minimum dominating set in a tournament

  • Nimrod Megiddo
  • Uzi Vishkin

The problem of finding a minimum dominating set in a tournament can be solved in n O(log n ) time. It is shown that if this problem has a polynomial-time algorithm, then for every constant C, there is also a polynomial-time algorithm for the satisfiability problem of boolean formulas in conjunctive normal form with m clauses and C log2 m variables. On the other hand, the problem can be reduced in polynomial time to a general satisfiability problem of length L with O(log2 L) variables. Another relation between the satisfiability problem and the minimum dominating set in a tournament says that the former can be solved in 2O(√v) nK time (where v is the number of variables, n is the length of the formula, and K is a constant) if and only if the latter has a polynomial-time algorithm.

FOCS Conference 1986 Conference Paper

Approximate and Exact Parallel Scheduling with Applications to List, Tree and Graph Problems

  • Richard Cole 0001
  • Uzi Vishkin

We study two parallel scheduling problems and their use in designing parallel algorithms. First, we define a novel scheduling problem; it is solved by repeated, rapid, approximate reschedulings. This leads to a first optimal PRAM algorithm for list ranking, which runs in logarithmic time. Our second scheduling result is for computing prefix sums of logn bit numbers. We give an optimal parallel algorithm for the problem which runs in sublogarithmic time. These two scheduling results together lead to logarithmic time PRAM algorithms for the connectivity, biconnectivity and minimum spanning tree problems. The connectivity and biconnectivity algorithms are optimal unless m = o(nlog*n), in graphs of n vertices and m edges.

TCS Journal 1986 Journal Article

Efficient string matching with k mismatches

  • Gad M. Landau
  • Uzi Vishkin

Given a text of length n, a pattern of length m, and an integer k, we present an algorithm for finding all occurrences of the pattern in the text, each with at most k mismatches. The algorithm runs in O(k(m log m + n)) time.

TCS Journal 1986 Journal Article

Parallel ear decomposition search (EDS) and st-numbering in graphs

  • Yael Maon
  • Baruch Schieber
  • Uzi Vishkin

The linear time serial algorithm of Lempel et al. (1967) for testing planarity of graphs uses the linear time serial algorithm of Even and Tarjan (1976) for st-numbering. This st-numbering algorithm is based on depth-first search (DFS). A known conjecture states that DFS, which is a key technique in designing serial algorithms, is not amenable to poly-log time parallelism using ‘around linearly’ (or even polynomially) many processors. The first contribution of this paper is a general method for searching efficiently in parallel undirected graphs, called ear decomposition search (EDS). The second contribution demonstrates the applicability of this search method. We present an efficient parallel algorithm for st-numbering in a biconnected graph. The algorithm runs in logarithmic time using a linear number of processors on a concurrent-read concurrent-write (CRCW) PRAM. An efficient parallel algorithm for the problem did not exist before. The problem was not even known to be in NC.

FOCS Conference 1986 Conference Paper

Tight Complexity Bounds for Parallel Comparison Sorting

  • Noga Alon
  • Yossi Azar
  • Uzi Vishkin

The time complexity of sorting n elements using p ≥ n processors on Valiant's parallel comparison tree model is considered. The following results are obtained. 1. We show that this time complexity is Θ(logn/log(1+p/n)). This complements the AKS sorting network in settling the wider problem of comparison sort of n elements by p processors, where the problem for p ≤ n was resolved. To prove the lower bound, we show that to achieve time k ≤ logn, we need Ω(kn1+1/k) comparisons. Häggkvist and Hell proved a similar result only for fixed k. 2. For every fixed time k, we show that: (a) Ω(n1+1/k lognl/k) comparisons are required, (O(n1+1/k logn) are known to be sufficient in this case), and (b) there exists a randomized algorithm for comparison sort in time k with an expected number of O(n1+1/k) comparisons. This implies that for every fixed k, any deterministic comparison sort algorithm must be asymptotically worse than this randomized algorithm. The lower bound improves on Häggkvist-Hell's lower bound. 3. We show that "approximate sorting" in time 1 requires asymptotically more than nlogn processors. This settles a problem raised by M. Rabin.

FOCS Conference 1985 Conference Paper

Efficient String Matching in the Presence of Errors

  • Gad M. Landau
  • Uzi Vishkin

Consider the string matching problem where differences between characters of the pattern and characters of the text are allowed. Each difference is due to either a mismatch between a character of the text and a character of the pattern or a superfluous character in the text or a superfluous character in the pattern. Given a text of length n, a pattern of length m and an integer k, we present an algorithm for finding all occurrences of the pattern in the text, each with at most k differences. The algorithm runs in O(m2 + k2n) time. Given the same input we also present an algorithm for finding all occurrences of the pattern in the text, each with at most k mismatches (superfluous characters in either the text or the pattern are not allowed). This algorithm runs in O(k(m logm + n)) time.

TCS Journal 1984 Journal Article

A parallel-design distributed-implementation (PDDI) general-purpose computer

  • Uzi Vishkin

A scheme of an efficient general-purpose parallel computer is introduced. Its design space (i. e. , the model for which parallel programs are written), is a permissive parallel RAM model of computation. The implementation space is presented as a scheme of a synchronous distributed machine which is not more involved than a sorting network followed by a merging network. An efficient translation from the design space into the implementation space is given. Suppose for some t and x there is a parallel algorithm in the design space which has depth (i. e. , parallel time) O( t p ) using p processors for all p⩽x. This translates to an algorithm in the implementation space with depth O( t s ) for all s⩽ t l where l depends on the choice of the sorting and merging networks, s is the number of ‘powerful’ processors used (processors not in the sorting or merging networks) and ƒ(s, m) auxiliary processors, where m is the size of the common memory in the design space. For a specific choice, l = log 2 s + log m and ƒ(s, m) = O(s log2 s + m log m), comparing favorably with alternative known solutions. Since many parallel algorithms are designed for a wide range of processors our solution pays the fine for implementation where it hurts least.

FOCS Conference 1984 Conference Paper

Finding Biconnected Components and Computing Tree Functions in Logarithmic Parallel Time (Extended Summary)

  • Robert Endre Tarjan
  • Uzi Vishkin

We propose a new algorithm for finding the blocks (biconnected components) of an undirected graph. A serial implementation runs in 0[n+m] time and space on a graph of n vertices and m edges. A parallel implmentation runs in 0[log n] time and 0[n+m] space using 0[n+m] processors on a concurrent-read, concurrent-write parallel RAM. An alternative implementation runs in 0[n/sup 2/p] time and 0[n/sup 2/] space using any number p ⩽ n/sup 2/log/sup 2/-n of processors, on a concurrent-read, exclusive-write parallel RAM. The latter algorithm has optimal speedup, assuming an adjacency matrix representation of the input. A general algorithmic technique which simplifies and improve computation of various functions on tress is introduced. This technique typically requires 0(log n) time using 0(n) space on an exclusive-read exclusive-write parallel RAM.

FOCS Conference 1983 Conference Paper

Trade-Offs between Depth and Width in Parallel Computation (Preliminary Version)

  • Uzi Vishkin
  • Avi Wigderson

A new technique for proving lower bounds for parallel computation is introduced. This technique enables us to obtain, for the first time. non-trivial tight lower bounds for shared-memory models of parallel computation that allow simultaneous read/write access to the same memory location. The size m of the common memory is called communication width or width in short. For a wide variety of problems (including parity and majority) we show that the time complexity T (depth) and the communication width m are related by the trade-off curve mT2 = Ω(n) (where n is the size of the input). This bound is tight lot every m ≤n/log2n We extend our technique to prove mT3 = Ω(n) trade-off for a class of "simpler" functions (includind Boolean Or) on a weaker model that forbids simultaneous write access. This result improves the lower bound of Cook and Dwork [CD-82] when communication is limited.

FOCS Conference 1982 Conference Paper

A Complexity Theory for Unbounded Fan-In Parallelism

  • Ashok K. Chandra
  • Larry J. Stockmeyer
  • Uzi Vishkin

A complexity theory for unbounded fan-in parallelism is developed where the complexity measure is the simultaneous measure (number of processors, parallel time). Two models of unbounded fan-in parallelism are (1) parallel random access machines that allow simultaneous reading from or writing to the same common memory location, and (2) circuits containing AND's, OR's and NOT's with no bound placed on the fan-in of gates. It is shown that these models can simulate one another with the number of processors preserved to within a polynomial and parallel time preserved to within a constant factor. Reducibilities that preserve the measure in this sense are defined and several reducibilities and equivalences among problems are given. New upper bounds on the (unbounded fan-in) circuit complexity of symmetric Boolean functions are proved.

v2026.09.13