arXiv subjects

Lorenzo De Stefani

Publications and source records attributed to Lorenzo De Stefani.

13 recordsLinked to original sources

arXiv2024

On the I/O Complexity of the CYK Algorithm and of a Family of Related DP Algorithms

Asymptotically tight lower bounds are derived for the Input/Output (I/O) complexity of a class of dynamic programming algorithms including matrix chain multiplication, optimal polygon triangulation, and the construction of optimal binary search trees. Assuming no recomputation of intermediate values, we establish an $Ω\left(\frac{n^3}{\sqrt{M}B}\right)$ I/O lower bound, where $n$ denotes the size of the input and $M$ denotes the size of the available fast memory (cache). When recomputation is allowed, we show the same bound holds for $M < cn$, where $c$ is a positive constant. In the case where $M \ge 2n$, we show an $Ω\left(n/B\right)$ I/O lower bound. We also discuss algorithms for which the number of executed I/O operations matches asymptotically each of the presented lower bounds, which are thus asymptotically tight. Additionally, we refine our general method to obtain a lower bound for the I/O complexity of the Cocke-Younger-Kasami algorithm, where the size of the grammar impacts the I/O complexity. An upper bound with asymptotically matching performance in many cases is also provided.

cs.DS↗

arXiv2024

A universal bound on the space complexity of Directed Acyclic Graph computations

It is shown that $S(G) = O\left(m/\log_2 m + d\right)$ pebbles are sufficient to pebble any DAG $G=(V,E)$, with $m$ edges and maximum in-degree $d$. It was previously known that $S(G) = O\left(d n/\log n\right)$. The result builds on two novel ideas. The first is the notion of $B-budget\ decomposition$ of a DAG $G$, an efficiently computable partition of $G$ into at most $2^{\lfloor \frac{m}{B} \rfloor}$ sub-DAGs, whose cumulative space requirement is at most $B$. The second is the challenging vertices technique, which constructs a pebbling schedule for $G$ from a pebbling schedule for a simplified DAG $G'$, obtained by removing from $G$ a selected set of vertices $W$ and their incident edges. This technique also yields improved pebbling upper bounds for DAGs with bounded genus and for DAGs with bounded topological depth.

cs.CC↗

arXiv2022

The DAG Visit approach for Pebbling and I/O Lower Bounds

We introduce the notion of an $r$-visit of a Directed Acyclic Graph DAG $G=(V,E)$, a sequence of the vertices of the DAG complying with a given rule $r$. A rule $r$ specifies for each vertex $v\in V$ a family of $r$-enabling sets of (immediate) predecessors: before visiting $v$, at least one of its enabling sets must have been visited. Special cases are the $r^{(top)}$-rule (or, topological rule), for which the only enabling set is the set of all predecessors and the $r^{(sin)}$-rule (or, singleton rule), for which the enabling sets are the singletons containing exactly one predecessor. The $r$-boundary complexity of a DAG $G$, $b_{r}\left(G\right)$, is the minimum integer $b$ such that there is an $r$-visit where, at each stage, for at most $b$ of the vertices yet to be visited an enabling set has already been visited. By a reformulation of known results, it is shown that the boundary complexity of a DAG $G$ is a lower bound to the pebbling number of the reverse DAG, $G^R$. Several known pebbling lower bounds can be cast in terms of the $r^{(sin)}$-boundary complexity. A visit partition technique for I/O lower bounds, which generalizes the $S$-partition I/O technique introduced by Hong and Kung in their classic paper "I/O complexity: The Red-Blue pebble game". The visit partition approach yields tight I/O bounds for some DAGs for which the $S$-partition technique can only yield an $Ω(1)$ lower bound.

cs.DS↗

arXiv2020

Communication-Optimal Parallel Standard and Karatsuba Integer Multiplication in the Distributed Memory Model

We present COPSIM a parallel implementation of standard integer multiplication for the distributed memory setting, and COPK a parallel implementation of Karatsuba's fast integer multiplication algorithm for a distributed memory setting. When using $\mathcal{P}$ processors, each equipped with a local non-shared memory, to compute the product of tho $n$-digits integer numbers, under mild conditions, our algorithms achieve optimal speedup of the computational time. That is, $\mathcal{O}\left(n^2/\mathcal{P}\right)$ for COPSIM, and $\mathcal{O}\left(n^{\log_2 3}/\mathcal{P}\right)$ for COPK. The total amount of memory required across the processors is $\mathcal{O}\left(n\right)$, that is, within a constant factor of the minimum space required to store the input values. We rigorously analyze the Input/Output (I/O) cost of the proposed algorithms. We show that their bandwidth cost (i.e., the number of memory words sent or received by at least one processors) matches asymptotically corresponding known I/O lower bounds, and their latency (i.e., the number of messages sent or received in the algorithm's critical execution path) is asymptotically within a multiplicative factor $\mathcal{O}\left(\log^2_2 \mathcal{P}\right)$ of the corresponding known I/O lower bounds. Hence, our algorithms are asymptotically optimal with respect to the bandwidth cost and almost asymptotically optimal with respect to the latency cost.

cs.DC↗

arXiv2020

On the I/O complexity of hybrid algorithms for Integer Multiplication

Almost asymptotically tight lower bounds are derived for the Input/Output (I/O) complexity $IO_\mathcal{A}\left(n,M\right)$ of a general class of hybrid algorithms computing the product of two integers, each represented with $n$ digits in a given base $s$, in a two-level storage hierarchy with $M$ words of fast memory, with different digits stored in different memory words. The considered hybrid algorithms combine the Toom-Cook-$k$ (or Toom-$k$) fast integer multiplication approach with computational complexity $Θ\left(c_kn^{\log_k \left(2k-1\right)}\right)$, and "standard" integer multiplication algorithms which compute $Ω\left(n^2\right)$ digit multiplications. We present an $Ω\left(\left(n/\max\{M,n_0\}\right)^{\log_k \left(2k-1\right)}\left(\max\{1,n_0/M\}\right)^2M\right)$ lower bound for the I/O complexity of a class of "uniform, non-stationary" hybrid algorithms, where $n_0$ denotes the threshold size of sub-problems which are computed using standard algorithms with algebraic complexity $Ω\left(n^2\right)$. As a special case, our result yields an asymptotically tight $Θ\left(n^2/M\right)$ lower bound for the I/O complexity of any standard integer multiplication algorithm. As some sequential hybrid algorithms from this class exhibit I/O cost within a $\mathcal{O}\left(k^2\right)$ multiplicative term of the corresponding lower bounds, the proposed lower bounds are almost asymptotically tight and indeed tight for constant values of $k$. By extending these results to a distributed memory model with $n_0$ processors, we obtain both memory-dependent and memory-independent I/O lower bounds for parallel versions of hybrid integer multiplication algorithms. All the lower bounds are derived for the more general class of "non-uniform, non-stationary" hybrid algorithms that allow recursive calls to have a different structure.

cs.CC↗

arXiv2019

A Rademacher Complexity Based Method fo rControlling Power and Confidence Level in Adaptive Statistical Analysis

While standard statistical inference techniques and machine learning generalization bounds assume that tests are run on data selected independently of the hypotheses, practical data analysis and machine learning are usually iterative and adaptive processes where the same holdout data is often used for testing a sequence of hypotheses (or models), which may each depend on the outcome of the previous tests on the same data. In this work, we present RadaBound a rigorous, efficient and practical procedure for controlling the generalization error when using a holdout sample for multiple adaptive testing. Our solution is based on a new application of the Rademacher Complexity generalization bounds, adapted to dependent tests. We demonstrate the statistical power and practicality of our method through extensive simulations and comparisons to alternative approaches.

eess.SP↗

arXiv2019

The I/O complexity of hybrid algorithms for square matrix multiplication

Asymptotically tight lower bounds are derived for the I/O complexity of a general class of hybrid algorithms computing the product of $n \times n$ square matrices combining ``\emph{Strassen-like}'' fast matrix multiplication approach with computational complexity $Θ{n^{\log_2 7}}$, and ``\emph{standard}'' matrix multiplication algorithms with computational complexity $Ω\left(n^3\right)$. We present a novel and tight $Ω\left(\left(\frac{n}{\max\{\sqrt{M},n_0\}}\right)^{\log_2 7}\left(\max\{1,\frac{n_0}{M}\}\right)^3M\right)$ lower bound for the I/O complexity a class of ``\emph{uniform, non-stationary}'' hybrid algorithms when executed in a two-level storage hierarchy with $M$ words of fast memory, where $n_0$ denotes the threshold size of sub-problems which are computed using standard algorithms with algebraic complexity $Ω\left(n^3\right)$. The lower bound is actually derived for the more general class of ``\emph{non-uniform, non-stationary}'' hybrid algorithms which allow recursive calls to have a different structure, even when they refer to the multiplication of matrices of the same size and in the same recursive level, although the quantitative expressions become more involved. Our results are the first I/O lower bounds for these classes of hybrid algorithms. All presented lower bounds apply even if the recomputation of partial results is allowed and are asymptotically tight. The proof technique combines the analysis of the Grigoriev's flow of the matrix multiplication function, combinatorial properties of the encoding functions used by fast Strassen-like algorithms, and an application of the Loomis-Whitney geometric theorem for the analysis of standard matrix multiplication algorithms. Extensions of the lower bounds for a parallel model with $P$ processors are also discussed.

cs.DS↗

arXiv2018

VizRec: A framework for secure data exploration via visual representation

Visual representations of data (visualizations) are tools of great importance and widespread use in data analytics as they provide users visual insight to patterns in the observed data in a simple and effective way. However, since visualizations tools are applied to sample data, there is a a risk of visualizing random fluctuations in the sample rather than a true pattern in the data. This problem is even more significant when visualization is used to identify interesting patterns among many possible possibilities, or to identify an interesting deviation in a pair of observations among many possible pairs, as commonly done in visual recommendation systems. We present VizRec, a framework for improving the performance of visual recommendation systems by quantifying the statistical significance of recommended visualizations. The proposed methodology allows to control the probability of misleading visual recommendations using both classical statistical testing procedures and a novel application of the Vapnik Chervonenkis (VC) dimension method which is a fundamental concept in statistical learning theory.

cs.DB↗

arXiv2017

Tiered Sampling: An Efficient Method for Approximate Counting Sparse Motifs in Massive Graph Streams

We introduce Tiered Sampling, a novel technique for approximate counting sparse motifs in massive graphs whose edges are observed in a stream. Our technique requires only a single pass on the data and uses a memory of fixed size $M$, which can be magnitudes smaller than the number of edges. Our methods addresses the challenging task of counting sparse motifs - sub-graph patterns that have low probability to appear in a sample of $M$ edges in the graph, which is the maximum amount of data available to the algorithms in each step. To obtain an unbiased and low variance estimate of the count we partition the available memory to tiers (layers) of reservoir samples. While the base layer is a standard reservoir sample of edges, other layers are reservoir samples of sub-structures of the desired motif. By storing more frequent sub-structures of the motif, we increase the probability of detecting an occurrence of the sparse motif we are counting, thus decreasing the variance and error of the estimate. We demonstrate the advantage of our method in the specific applications of counting sparse 4 and 5-cliques in massive graphs. We present a complete analytical analysis and extensive experimental results using both synthetic and real-world data. Our results demonstrate the advantage of our method in obtaining high-quality approximations for the number of 4 and 5-cliques for large graphs using a very limited amount of memory, significantly outperforming the single edge sample approach for counting sparse motifs in large scale graphs.

cs.DS↗

arXiv2016

Controlling False Discoveries During Interactive Data Exploration

Recent tools for interactive data exploration significantly increase the chance that users make false discoveries. The crux is that these tools implicitly allow the user to test a large body of different hypotheses with just a few clicks thus incurring in the issue commonly known in statistics as the multiple hypothesis testing error. In this paper, we propose solutions to integrate multiple hypothesis testing control into interactive data exploration tools. A key insight is that existing methods for controlling the false discovery rate (such as FDR) are not directly applicable for interactive data exploration. We therefore discuss a set of new control procedures that are better suited and integrated them in our system called Aware. By means of extensive experiments using both real-world and synthetic data sets we demonstrate how Aware can help experts and novice users alike to efficiently control false discoveries.

cs.DB↗

arXiv2016

TRIÈST: Counting Local and Global Triangles in Fully-dynamic Streams with Fixed Memory Size

We present TRIÈST, a suite of one-pass streaming algorithms to compute unbiased, low-variance, high-quality approximations of the global and local (i.e., incident to each vertex) number of triangles in a fully-dynamic graph represented as an adversarial stream of edge insertions and deletions. Our algorithms use reservoir sampling and its variants to exploit the user-specified memory space at all times. This is in contrast with previous approaches which use hard-to-choose parameters (e.g., a fixed sampling probability) and offer no guarantees on the amount of memory they will use. We show a full analysis of the variance of the estimations and novel concentration bounds for these quantities. Our experimental results on very large graphs show that TRIÈST outperforms state-of-the-art approaches in accuracy and exhibits a small update time.

cs.DS↗

arXiv2016

The I/O complexity of Strassen's matrix multiplication with recomputation

A tight $Ω((n/\sqrt{M})^{\log_2 7}M)$ lower bound is derived on the \io complexity of Strassen's algorithm to multiply two $n \times n$ matrices, in a two-level storage hierarchy with $M$ words of fast memory. A proof technique is introduced, which exploits the Grigoriev's flow of the matrix multiplication function as well as some combinatorial properties of the Strassen computational directed acyclic graph (CDAG). Applications to parallel computation are also developed. The result generalizes a similar bound previously obtained under the constraint of no-recomputation, that is, that intermediate results cannot be computed more than once. For this restricted case, another lower bound technique is presented, which leads to a simpler analysis of the \io complexity of Strassen's algorithm and can be readily extended to other "Strassen-like" algorithms.

cs.DS↗

arXiv2015

Exploiting non-constant safe memory in resilient algorithms and data structures

We extend the Faulty RAM model by Finocchi and Italiano (2008) by adding a safe memory of arbitrary size $S$, and we then derive tradeoffs between the performance of resilient algorithmic techniques and the size of the safe memory. Let $δ$ and $α$ denote, respectively, the maximum amount of faults which can happen during the execution of an algorithm and the actual number of occurred faults, with $α\leq δ$. We propose a resilient algorithm for sorting $n$ entries which requires $O\left(n\log n+α(δ/S + \log S)\right)$ time and uses $Θ(S)$ safe memory words. Our algorithm outperforms previous resilient sorting algorithms which do not exploit the available safe memory and require $O\left(n\log n+ αδ\right)$ time. Finally, we exploit our sorting algorithm for deriving a resilient priority queue. Our implementation uses $Θ(S)$ safe memory words and $Θ(n)$ faulty memory words for storing $n$ keys, and requires $O\left(\log n + δ/S\right)$ amortized time for each insert and deletemin operation. Our resilient priority queue improves the $O\left(\log n + δ\right)$ amortized time required by the state of the art.

cs.DS↗