Motivated by applications in production planning and storage allocation in hierarchical databases, we initiate the study of covering partially ordered items (cpo). Given a value k ∈ℕ , and a directed graph G=(V,E) where each vertex has a size in {0,1, … , k} , we seek a collection of subsets of vertices C_1, … , C_t that cover all the vertices, such that for any 1 ≤ j ≤ t , the total size of vertices in C_j is bounded by k, and there are no edges from V ∖ C_j to C_j . The objective is to minimize the number of subsets t. cpo is closely related to the rule caching problem (rcp) that has been widely studied in the networking area. The input for rcp is a directed graph G=(V,E) , a profit function p:V →ℤ_0^+ , and k ∈ℕ . The output is a subset S ⊆ V of maximum profit such that |S| ≤ k and there are no edges from V ∖ S to S. Our main result is a 2-approximation algorithm for cpo on out-trees, complemented by an asymptotic 1.5-hardness of approximation result. We also give a two-way reduction between rcp and the densest k-subhypergraph problem, surprisingly showing that the problems are equivalent with respect to polynomial-time approximation within any factor ρ≥ 1 . This implies that rcp cannot be approximated within factor |V|^1-ε for any fixed ε>0 , under standard complexity assumptions. Prior to this work, rcp was only known to be strongly NP-hard. We further show that there is no EPTAS for the special case of rcp where the profits are uniform, assuming Gap-ETH. Since this variant admits a PTAS, we essentially resolve the complexity status of this problem.

We introduce and study a novel problem of computing a shortest path tree with a minimum number of non-terminals. It can be viewed as an (unweighted) Steiner Shortest Path Tree (SSPT) that spans a given set of terminal vertices by shortest paths from a given source while minimizing the number of nonterminal vertices included in the tree. This problem is motivated by applications where shortest-path connections from a source are essential, and where reducing the number of intermediate vertices helps limit cost, complexity, or overhead. We show that the SSPT problem is NP-hard. To approximate it, we introduce and study the shortest path subgraph of a graph. Using it, we show an approximation-preserving reduction of SSPT to the uniform vertex-weighted variant of the Directed Steiner Tree (DST) problem, termed UVDST. Consequently, the algorithm of [Grandoni et al., 2023] approximating DST implies a quasi-polynomial polylog-approximation algorithm for SSPT. We present a polynomial polylog-approximation algorithm for UVDST, and thus for SSPT, for a restricted class of graphs.

We introduce and study a novel problem of computing a shortest path tree with the minimum number of non-terminals. It can be viewed as an (unweighted) Steiner Shortest Path Tree (SSPT) that spans a given set of terminal vertices by shortest paths from a given source while minimizing the number of nonterminal vertices included in the tree. This problem is motivated by applications where shortest-path connections from a source are essential, and where reducing the number of intermediate vertices helps limit cost, complexity, or overhead. We show that the SSPT problem is NP-hard. To approximate it, we introduce and study the shortest path subgraph of a graph. Using it, we show an approximation-preserving reduction of SSPT to the uniform vertex-weighted variant of the Directed Steiner Tree (DST) problem, termed UVDST. Consequently, the algorithm of [Grandoni et al., 2023] approximating DST, implies a quasi-polynomial polylog-approximation algorithm for SSPT. We present a polynomial polylog-approximation algorithm for UVDST, and thus for SSPT for a restricted class of graphs.

The private key associated with a blockchain is the sole means of linking a cryptocurrency asset to its owner, and any loss or compromise of this key could result in significant consequences. Typically, crypto-wallets generate a private key from a string of words, which users are advised to store in a private record, such as a piece of paper. This method poses several security risks, as the private record holding the secret words can leak the private key. Additionally, private records are vulnerable to being lost or destroyed, leading to the potential loss of assets. Moreover, clients have limited control over the generation of their private key, as the wallet generates it. Our approach empowers clients to securely generate and manage their own private keys, minimizing the risk of key loss. We have developed an open-source technique that allows clients to use memorized secrets to store and retrieve their private keys. Our method employs Bloom filters with hash functions, such as SHA-256, to store and retrieve the private key from the Bloom filter securely.

Given a large number (notationally m ) of users' (members or preferences as inputs over a large number of items or candidates (notationally n ), preference queries leverage different preference aggregation methods to aggregate individual preferences tematic manner and come up with a single output (either a order or top-k, ordered or unordered) that is most representative of the users' preferences. The goal of this 1.5 hour lecture tutorial is to adapt different preference aggregation methods social choice theories, summarize how existing research dled fairness over these methods, identify their limitations, outline new research directions.

One of the ways to increase communication reliability is by sending k duplicate messages along different routes. This gives rise to the problem of finding k shortest paths between a given source and destination. An unconstrained solution of the k shortest paths problem may output paths that overlap in almost all edges. Clearly, using such paths will have an adverse impact on the communication reliability. On the other extreme, a solution of k independent shortest paths, which are paths that share neither an edge nor an intermediate node may not be realistic for several reasons: such paths may not exist, if they exist they may be very long compared to the shortest path, and the computational effort of finding such paths may be prohibitive. This motivated us to investigate the intermediate case in which the number of edges that are not shared among any two paths in the output k paths is parameterized. We explore both exactly shortest paths and near-shortest paths. Our results are also generalized to the case of multi-criteria prioritized weights. Next, we consider the related albeit different problem of computing the k shortest paths trees, which are the k spanning trees with minimum total path length. This problem was introduced by Sedeño-Noda and González-Martín (2010). They solved it using a greedy algorithm and proved its correctness using linear programming theory. We provide an alternative, combinatorial and simpler proof of the correctness of the same greedy algorithm. We believe that the combinatorial approach can lead to a better understanding and possible extensions of the related results.

We examine the amount of preprocessing needed for answering certain on-line queries as fast as possible. We start with the following basic problem. Suppose we are given a semigroup (S,∘ ). Let s_1 ,…, s_n be elements of S. We want to answer on-line queries of the form, “What is the product s_i ∘ s_i+1∘⋯∘ s_j-1∘ s_j?” for any given 1≤ i≤ j≤ n. We show that a preprocessing of Θ(n λ (k,n)) time and space is both necessary and sufficient to answer each such query in at most k steps, for any fixed k. The function λ (k,·) is the inverse of a certain function at the ⌊k/2⌋-th level of the primitive recursive hierarchy. In case linear preprocessing is desired, we show that one can answer each such query in O( α (n)) steps and that this is best possible. The function α (n) is the inverse Ackermann function. We also consider the following extended problem. Let T be a tree with an element of S associated with each of its vertices. We want to answer on-line queries of the form, “What is the product of the elements associated with the vertices along the path from u to v?” for any pair of vertices u and v in T. We derive results that are similar to the above, for the preprocessing needed for answering such queries. All our sequential preprocessing algorithms can be parallelized efficiently to give optimal parallel algorithms which run in O(log n) time on a CREW PRAM. These parallel algorithms are optimal in both running time and total number of operations. Our algorithms, especially for the semigroup of the real numbers with the minimum or maximum operations, have various applications in certain graph algorithms, in the utilization of communication networks and in Database retrieval.

We investigate the problem of finding winner(s) given a large number of users' (voters') preferences casted as ballots, one from each of the m users, where each ballot is a ranked order of preference of up to ℓ out of n items (candidates). Given a group protected attribute with k different values and a priority that imposes a selection order among these groups, the goal is to satisfy the priority order and select a winner per group that is most representative. It is imperative that at times the original users' preferences may require further manipulation to meet these fairness and priority requirement. We consider manipulation by modifications and formalize the margin finding problem under modification problem. We study the suitability of Instant Run-off Voting (IRV) as a preference aggregation method and demonstrate its advantages over positional methods. We present a suite of technical results on the hardness of the problem, design algorithms with theoretical guarantees and further investigate efficiency opportunities. We present exhaustive experimental evaluations using multiple applications and large-scale datasets to demonstrate the effectiveness of IRV, and efficacy of our designed solutions qualitatively and scalability-wise.

The private key associated with a blockchain is the sole means of linking a cryptocurrency asset to its owner, and any loss or compromise of this key could result in significant consequences. Generally, crypto-wallets suggest a private key created from a string of words, which can be stored in a private record such as a piece of paper. The fact that the private record holds the secret words and can leak the private key poses security concerns. In addition, private records are susceptible to the risk of getting lost or destroyed, resulting in loss of assets. Furthermore, clients lack complete control over generating their private key, as the wallet itself creates it. Our approach enables clients to securely generate and manage their own private keys, minimizing the risk of key loss. We developed an open-source technique allowing clients to employ memorized secrets to store and retrieve their private keys. We utilize Bloom filters using hash functions, such as SHA-256, to store and retrieve the private key from the Bloom filter.

We revisit a classical scheduling model to incorporate modern trends in data center networks and cloud services. Addressing some key challenges in the allocation of shared resources to user requests (jobs) in such settings, we consider the following variants of the classic resource allocation problem (RAP). The input to our problems is a set J of jobs and a set M of homogeneous hosts, each has an available amount of some resource. Assuming that time is slotted, a job is associated with a release time, a due date, a weight and a given length, as well as its resource requirement. A feasible schedule is an allocation of the resource to a subset of the jobs, satisfying the job release times/due dates as well as the resource constraints. A crucial distinction between classic RAP and our problems is that we allow preemption and migration of jobs, motivated by virtualization techniques. We consider two natural objectives: throughput maximization (MaxT), which seeks a maximum weight subset of the jobs that can be feasibly scheduled on the hosts in M, and resource minimization (MinR), that is finding the minimum number of (homogeneous) hosts needed to feasibly schedule all jobs. Both problems are known to be NP-hard. We first present an Ω (1) -approximation algorithm for MaxT instances where time-windows form a laminar family of intervals. We then extend the algorithm to handle instances with arbitrary time-windows, assuming there is sufficient slack for each job to be completed. For MinR we study a more general setting with d resources and derive an O(log d) -approximation for any fixed d ≥ 1 , under the assumption that time-windows are not too small. This assumption can be removed leading to a slightly worse ratio of O(log dlog ^* T) , where T is the maximum due date of any job.

We consider the problem of minimizing the total processing time of tardy jobs on a single machine. This is a classical scheduling problem, first considered by [Lawler and Moore 1969], that also generalizes the Subset Sum problem. Recently, it was shown that this problem can be solved efficiently by computing $(\max,\min)$-skewed-convolutions. The running time of the resulting algorithm is equivalent, up to logarithmic factors, to the time it takes to compute a $(\max,\min)$-skewed-convolution of two vectors of integers whose sum is $O(P)$, where $P$ is the sum of the jobs' processing times. We further improve the running time of the minimum tardy processing time computation by introducing a job ``bundling'' technique and achieve a $\tilde{O}\left(P^{2-1/\alpha}\right)$ running time, where $\tilde{O}\left(P^\alpha\right)$ is the running time of a $(\max,\min)$-skewed-convolution of vectors of size $P$. This results in a $\tilde{O}\left(P^{7/5}\right)$ time algorithm for tardy processing time minimization, an improvement over the previously known $\tilde{O}\left(P^{5/3}\right)$ time algorithm.

One of the most critical problems in the field of string algorithms is the longest common subsequence problem (LCS). The problem is NP-hard for an arbitrary number of strings but can be solved in polynomial time for a fixed number of strings. In this paper, we select a typical parallel LCS algorithm and integrate it into our large-scale string analysis algorithm library to support different types of large string analysis. Specifically, we take advantage of the high-level parallel language, Chapel, to integrate Lu and Liu's parallel LCS algorithm into Arkouda, an open-source framework. Through Arkouda, data scientists can easily handle large string analytics on the back-end high-performance computing resources from the front-end Python interface. The Chapel-enabled parallel LCS algorithm can identify the longest common subsequences of two strings, and experimental results are given to show how the number of parallel resources and the length of input strings can affect the algorithm's performance.

Given m users (voters), where each user casts her preference for a single item (candidate) over n items (candidates) as a ballot, the preference aggregation problem returns k items (candidates) that have the k highest number of preferences (votes). Our work studies this problem considering complex fairness constraints that have to be satisfied via proportionate representations of different values of the group protected attribute(s) in the top- k results. Precisely, we study the margin finding problem under single ballot substitutions , where a single substitution amounts to removing a vote from candidate i and assigning it to candidate j and the goal is to minimize the number of single ballot substitutions needed to guarantee that the top-k results satisfy the fairness constraints. We study several variants of this problem considering how top- k fairness constraints are defined, (i) MFBinaryS and MFMultiS are defined when the fairness (proportionate representation) is defined over a single, binary or multivalued, protected attribute, respectively; (ii) MF-Multi2 is studied when top- k fairness is defined over two different protected attributes; (iii) MFMulti3+ investigates the margin finding problem, considering 3 or more protected attributes. We study these problems theoretically, and present a suite of algorithms with provable guarantees. We conduct rigorous large scale experiments involving multiple real world datasets by appropriately adapting multiple state-of-the-art solutions to demonstrate the effectiveness and scalability of our proposed methods.

Given multiple individual rank orders over a set of candidates or items, where the candidates belong to multiple (non-binary) protected groups, we study the classical rank aggregation problem subject to proportionate fairness or p-fairness (RAPF in short), considering Kemeny distance. We first study the problem of producing the closest p-fair ranking to an individual ranked order IPF in short) considering Kendall-Tau distance, and present multiple solutions for IPF. We then present two computational frameworks(a randomized randpickperm and a deterministic algpickperm) to solve RAPF that leverages the solutions of IPF as a subroutine. We make several non-trivial algorithmic contributions: (i) we prove that when the group protected attribute is binary, IPF can be solved exactly using a greedy technique; (ii) we present two different solutions for IPF when the group protected attribute is multi-valued, algexact is optimal and algapprox admits a 2 approximation factor; (iii) we design a framework for RAPF solution with an approximation factor that is 2+ the approximation factor of the IPF solution. The resulting randpickperm and algpickperm solutions exhibit 3 and 4 approximation factors when designed using algexact and algapprox, respectively. We run extensive experiments using multiple real world and large scale synthetic datasets and compare our proposed solutions against multiple state-of-the-art related works to demonstrate the effectiveness and efficiency of our studied problem and proposed solution.

A solution of the $k$ shortest paths problem may output paths that are identical up to a single edge. On the other hand, a solution of the $k$ independent shortest paths problem consists of paths that share neither an edge nor an intermediate node. We investigate the case in which the number of edges that are not shared among any two paths in the output $k$-set is a parameter. We study two main directions: exploring \emph{near-shortest} paths and exploring \emph{exactly shortest paths}. We assume that the weighted graph $G=(V,E,w)$ has no parallel edges and that the edge lengths (weights) are positive. Our results are also generalized to the cases of $k$ shortest paths where there are several weights per edge, and the results should take into account the multi-criteria prioritized weight.

We consider scheduling real-time jobs in the classic flow shop model. The input is a set of n jobs, each consisting of m segments to be processed on m machines in the specified order, such that segment I_i of a job can start processing on machine M_i only after segment I_{i-1} of the same job completed processing on machine M_{i-1}, for 2 ≤ i ≤ m. Each job also has a release time, a due date, and a weight. The objective is to maximize the throughput (or, profit) of the n jobs, i.e., to find a subset of the jobs that have the maximum total weight and can complete processing on the m machines within their time windows. This problem has numerous real-life applications ranging from manufacturing to cloud and embedded computing platforms, already in the special case where m = 2. Previous work in the flow shop model has focused on makespan, flow time, or tardiness objectives. However, little is known for the flow shop model in the real-time setting. In this work, we give the first nontrivial results for this problem and present a pseudo-polynomial time (2m+1)-approximation algorithm for the problem on m ≥ 2 machines, where m is a constant. This ratio is essentially tight due to a hardness result of Ω(m/(log m)) for the approximation ratio. We further give a polynomial-time algorithm for the two-machine case, with an approximation ratio of (9+e) where e = O(1/n). We obtain better bounds for some restricted subclasses of inputs with two machines. To the best of our knowledge, this fundamental problem of throughput maximization in the flow shop scheduling model is studied here for the first time.

We consider the problem of maintaining a maximal independent set in a dynamic graph subject to edge insertions and deletions. Recently, Assadi et al. (at STOC’18) showed that a maximal independent set can be maintained in sublinear (in the dynamically changing number of edges) amortized update time. In this article, we significantly improve the update time for uniformly sparse graphs . Specifically, for graphs with arboricity α, the amortized update time of our algorithm is O (α 2 ⋅ log 2 n ), where n is the number of vertices. For low arboricity graphs, which include, for example, minor-free graphs and some classes of “real-world” graphs, our update time is polylogarithmic. Our update time improves the result of Assadi et al. for all graphs with arboricity bounded by m 3/8−ϵ , for any constant ϵ > 0. This covers much of the range of possible values for arboricity, as the arboricity of a general graph cannot exceed m 1/2 .

We study the fair variant of the classic k-median problem introduced by Chierichetti et al. [2017]. In the standard k-median problem, given an input pointset P, the goal is to find k centers C and assign each input point to one of the centers in C such that the average distance of points to their cluster center is minimized. In the fair variant of k-median, the points are colored, and the goal is to minimize the same average distance objective while ensuring that all clusters have an "approximately equal" number of points of each color. Chierichetti et al. proposed a two-phase algorithm for fair k-clustering. In the first step, the pointset is partitioned into subsets called fairlets that satisfy the fairness requirement and approximately preserve the k-median objective. In the second step, fairlets are merged into k clusters by one of the existing k-median algorithms. The running time of this algorithm is dominated by the first step, which takes super-quadratic time. In this paper, we present a practical approximate fairlet decomposition algorithm that runs in nearly linear time. Our algorithm additionally allows for finer control over the balance of resulting clusters than the original work. We complement our theoretical bounds with empirical evaluation.

We present a simple combinatorial $\frac{1 -e^{-2}}{2}$-approximation algorithm for maximizing a monotone submodular function subject to a knapsack and a matroid constraint. This classic problem is known to be hard to approximate within factor better than $1 - 1/e$. We show that the algorithm can be extended to yield a ratio of $\frac{1 - e^{-(k+1)}}{k+1}$ for the problem with a single knapsack and the intersection of $k$ matroid constraints, for any fixed $k > 1$. Our algorithms, which combine the greedy algorithm of [Khuller, Moss and Naor, 1999] and [Sviridenko, 2004] with local search, show the power of this natural framework in submodular maximization with combined constraints.