A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2017; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Optimal parallel selection has complexity O(Log Log N)

1989
*
Journal of computer and system sciences (Print)
*

We show that

doi:10.1016/0022-0000(89)90035-4
fatcat:z7kk67veffhm7fttm2gxwuwwvq
*in*the*deterministic*comparison model for*parallel*computation, p=*n*processors can*select*the kth smallest item from a set of*n*numbers*in**O*(*log**log**n*)*parallel**time*. ... This optimal*time*bound holds even if p =*o*(*n*). ... ACKNOWLEDGMENT We thank Jeff Salowe for help*in*preparing the paper. ...##
###
MST construction in O(log log n) communication rounds

2003
*
Proceedings of the fifteenth annual ACM symposium on Parallel algorithms and architectures - SPAA '03
*

This result is the first to break the Ω(

doi:10.1145/777412.777428
dblp:conf/spaa/LotkerPPP03
fatcat:j3krvcrcb5ca3glgpmwadwlk7q
*log**n*)*parallel**time*complexity barrier with small message sizes. ... For this model, we present a distributed algorithm that constructs a minimumweight spanning tree*in**O*(*log**log**n*) communication rounds, where*in*each round any process can send a message to each other process ... This can be done*in**O*(*log**n*)*time*. To reduce the*time*complexity to*O*(*log**log**n*), it is necessary to speed up the process by making the cluster sizes grow quadratically*in*each phase. ...##
###
MST construction in O(log log n) communication rounds

2003
*
Proceedings of the fifteenth annual ACM symposium on Parallel algorithms and architectures - SPAA '03
*

This result is the first to break the Ω(

doi:10.1145/777426.777428
fatcat:4cdmg4apbzghxn7niolz5ovhxe
*log**n*)*parallel**time*complexity barrier with small message sizes. ... For this model, we present a distributed algorithm that constructs a minimumweight spanning tree*in**O*(*log**log**n*) communication rounds, where*in*each round any process can send a message to each other process ... This can be done*in**O*(*log**n*)*time*. To reduce the*time*complexity to*O*(*log**log**n*), it is necessary to speed up the process by making the cluster sizes grow quadratically*in*each phase. ...##
###
Mutual Exclusion with O(log^2 Log n) Amortized Work

2011
*
2011 IEEE 52nd Annual Symposium on Foundations of Computer Science
*

This paper presents a new algorithm for mutual exclusion

doi:10.1109/focs.2011.84
dblp:conf/focs/BenderG11
fatcat:loqdendnlzcktc3nbbnadixyhi
*in*which each passage through the critical section costs amortized*O*(*log*2*log**n*) RMRs with high probability. ... The algorithm operates*in*a standard asynchronous, local spinning, sharedmemory model with an oblivious adversary. It guarantees that every process enters the critical section with high probability. ... This research was supported*in*part by NSF Grants CCF 0937822, CCF 1114809, CCF 0634793, and CCF 0540897, DOE Grant DE-FG02-08ER25853, and NUS FRC R-252-000-443-133. ...##
###
A deterministic poly(log log N)-time N-processor algorithm for linear programming in fixed dimension

1992
*
Proceedings of the twenty-fourth annual ACM symposium on Theory of computing - STOC '92
*

The

doi:10.1145/129712.129744
dblp:conf/stoc/AjtaiM92
fatcat:spcyu4clq5gd3fpf4obmbhc6py
*parallel**time*bound (counting only the arithmetic operations) is*O*((*log**log**n*) d ) where d is the number of variables.*In*the one-dimensional case this bound is optimal. ... It is shown that for any x e d*n*umb e r*o*f v ariables, the linear programming problems with*n*linear inequalities can be solved*deterministically*by*n**parallel*processors*in*sub-logarithmic*time*. ... Deng 5] gave a*parallel*algorithm which runs*in**O*(*log**n*)*time*, using*O*(*n*=*log**n*) processors. ...##
###
Minimum-Weight Spanning Tree Construction in O(log log n) Communication Rounds

2005
*
SIAM journal on computing (Print)
*

For this model, we present a distributed algorithm which constructs a minimum-weight spanning tree

doi:10.1137/s0097539704441848
fatcat:e5nknu7onnhqlenfmyqz33mvmm
*in**O*(*log**log**n*) communication rounds, where*in*each round any process can send a message to every other ... If message size is Θ(*n*) for some > 0, then the number of communication rounds is*O*(*log*1 ). ... This can be done*in**O*(*log**n*)*time*. To reduce the*time*complexity to*O*(*log**log**n*), it is necessary to speed up the process by making the cluster sizes grow quadratically*in*each phase. ...##
###
An n log n Algorithm for Online BDD Refinement

1995
*
BRICS Report Series
*

<br />We apply our algorithm to show that automata with exponentially<br />large, but implicitly represented alphabets, can be minimized

doi:10.7146/brics.v2i29.19931
fatcat:vuy4lqvhjjak5avelvpms4jaau
*in**time*<br />*O*(*n**log**n*), where*n*is the total number of BDD nodes ... <br />*In*this paper, we consider a natural online BDD refinement problem<br />and show that it can be solved*in**O*(*n**log**n*) if*n*bounds the size of the<br />BDD and the total size of update operations. ... Thus the total*time*is*O*(*n**log**n*+k). ...##
###
Breaking the log n barrier on rumor spreading
[article]

2015
*
arXiv
*
pre-print

This algorithm can also cope with F=

arXiv:1512.03022v1
fatcat:7qrg3fahz5avvam7i42s2wruo4
*O*(*n*/2^√(*n*)) node failures,*in*which case all but*O*(F) nodes become informed within*O*(√(*n*)) rounds, w.h.p. ...*O*(*n*) rounds has been a well known upper bound for rumor spreading using push&pull*in*the random phone call model (i.e., uniform gossip*in*the complete graph). ...*in*a spreading*time*of*O*(*log**n**log**log**n*). ...##
###
Population protocols for leader election and exact majority with O(log^2 n) states and O(log^2 n) convergence time
[article]

2017
*
arXiv
*
pre-print

[SODA 2017] showed

arXiv:1705.01146v1
fatcat:ynf7cxqjxbchdhu53bjp73dnb4
*O*(^2*n*)-state protocols for both problems, with the exact majority protocol converging*in**time**O*(^3*n*), and the leader election protocol converging*in**time**O*(^6.3*n*) w.h.p. and*O*(^5.3 ... We present a protocol which elects the leader*in**O*(^2*n*)*time*w.h.p. and*in*expectation and uses Θ(^2*n*) states per agent. ... W.h.p.*in**O*(*log**n*) (*parallel*)*time*all nodes have the message. ...##
###
Sorting Short Keys in Circuits of Size o(n log n)
[article]

2020
*
arXiv
*
pre-print

*in*such cases. ... Therefore, if the keys to be sorted are short, say, k <

*o*(

*log*

*n*), our result is asymptotically better than the classical AKS sorting network (ignoring

*log*^* terms); and we also overcome the

*n*

*log*

*n*barrier ... This work is

*in*part supported by an NSF CAREER Award under the award number CNS-1601879, a Packard Fellowship, an ONR YIP award, and a DARPA Brandeis award. ...

##
###
Representing hard lattices with O(n log n) bits

2005
*
Proceedings of the thirty-seventh annual ACM symposium on Theory of computing - STOC '05
*

We present a variant of the Ajtai-Dwork public-key cryptosystem where the size of the public-key is only

doi:10.1145/1060590.1060604
dblp:conf/stoc/Ajtai05
fatcat:dbp4q3d7u5gh5niiihzvmxhm4a
*O*(*n**log**n*) bits and the encrypted text/clear text ratio is also*O*(*n**log**n*). ... This is true with the assumption that all of the participants*in*the cryptosystem share*O*(*n*2*log**n*) random bits which have to be picked only once and the users of the cryptosystem get them e.g. together ... Moreover*in*the new system the public key consists of only*O*(*n**log**n*) bits and we encrypt a single bit by*O*(*n**log**n*) bits. ...##
###
Efficient Range ORAM with 핆(log 2 N) Locality
[article]

2018
*
IACR Cryptology ePrint Archive
*

*log*

*N*). ... can also speed up standard ORAM constructions, e.g., resulting

*in*a 2x faster Path ORAM variant. ... number of

*parallel*seeks per access is

*O*

*log*

*N*• 1 +

*log*

*N*k . ...

##
###
Parallel Minimum Cuts in O(m log^2(n)) Work and Low Depth
[article]

2021
*
arXiv
*
pre-print

We present an

arXiv:2102.05301v1
fatcat:5wbcjmxcbfgy5hn6lnah6fxylm
*O*(m*log*^2(*n*)) work,*O*(polylog(*n*)) depth*parallel*algorithm for minimum cut. ... and Gianinazzi [SPAA'18, (2018), pp. 1-11] which performs*O*(m*log*^4(*n*)) work*in**O*(polylog(*n*)) depth. ... Acknowledgments This work was supported*in*part by NSF grants CCF-1408940 and CCF-1629444. ...##
###
Perfect Information Leader Election in log*n+O(1) Rounds

2001
*
Journal of computer and system sciences (Print)
*

Our protocol takes

doi:10.1006/jcss.2001.1776
fatcat:p6a6mqhivrcxbimyz25eeje6c4
*log**n*+*O*(1) rounds, each player sending at most*log**n*bits per round. ... k*times*. ... The*time*to construct such a function*deterministically*is*n**O*(*n*) . Proof. ...##
###
NanoGRAM: Garbled RAM with $\widetilde{O}(\log N)$ Overhead
[article]

2022
*
IACR Cryptology ePrint Archive
*

For sufficiently large blocks where W = Ω(

dblp:journals/iacr/ParkLS22
fatcat:nm7oxobdjzhepjp3bnifv34lv4
*log*2*N*), our scheme achieves*O*(λ • W*log**N*) cost per memory access, where the dependence on*N*is optimal (barring poly*log**log*factors),*in*terms of the evaluator's ...*N*is the total number of blocks, and*O*(•) hides poly*log**log*factors. ... Acknowledgments This work is*in*part supported by a DARPA SIEVE grant, a Packard Fellowship, NSF awards under the grant numbers 2128519 and 2044679, and a grant from ONR. ...
« Previous

*Showing results 1 — 15 out of 47,602 results*