An EPTAS for Scheduling on Unrelated Machines of Few Different Types

In the classical problem of scheduling on unrelated parallel machines, a set of jobs has to be assigned to a set of machines. The jobs have a processing time depending on the machine and the goal is to minimize the makespan, that is the maximum machine load. It is well known that this problem is NP-hard and does not allow polynomial time approximation algorithms with approximation guarantees smaller than $1.5$ unless P$=$NP. We consider the case that there are only a constant number $K$ of machine types. Two machines have the same type if all jobs have the same processing time for them. This variant of the problem is strongly NP-hard already for $K=1$. We present an efficient polynomial time approximation scheme (EPTAS) for the problem, that is, for any $\varepsilon > 0$ an assignment with makespan of length at most $(1+\varepsilon)$ times the optimum can be found in polynomial time in the input length and the exponent is independent of $1/\varepsilon$. In particular we achieve a running time of $2^{\mathcal{O}(K\log(K) \frac{1}{\varepsilon}\log^4 \frac{1}{\varepsilon})}+\mathrm{poly}(|I|)$, where $|I|$ denotes the input length. Furthermore, we study three other problem variants and present an EPTAS for each of them: The Santa Claus problem, where the minimum machine load has to be maximized; the case of scheduling on unrelated parallel machines with a constant number of uniform types, where machines of the same type behave like uniformly related machines; and the multidimensional vector scheduling variant of the problem where both the dimension and the number of machine types are constant. For the Santa Claus problem we achieve the same running time. The results are achieved, using mixed integer linear programming and rounding techniques

Arithmetical Congruence Preservation: from Finite to Infinite

Various problems on integers lead to the class of congruence preserving functions on rings, i.e. functions verifying $a-b$ divides $f(a)-f(b)$ for all $a,b$. We characterized these classes of functions in terms of sums of rational polynomials (taking only integral values) and the function giving the least common multiple of $1,2,\ldots,k$. The tool used to obtain these characterizations is "lifting": if $\pi\colon X\to Y$ is a surjective morphism, and $f$ a function on $Y$ a lifting of $f$ is a function $F$ on $X$ such that $\pi\circ F=f\circ\pi$. In this paper we relate the finite and infinite notions by proving that the finite case can be lifted to the infinite one. For $p$-adic and profinite integers we get similar characterizations via lifting. We also prove that lattices of recognizable subsets of $Z$ are stable under inverse image by congruence preserving functions

Homomorphic encryption and some black box attacks

This paper is a compressed summary of some principal definitions and concepts in the approach to the black box algebra being developed by the authors. We suggest that black box algebra could be useful in cryptanalysis of homomorphic encryption schemes, and that homomorphic encryption is an area of research where cryptography and black box algebra may benefit from exchange of ideas

A Multivariate Approach for Checking Resiliency in Access Control

In recent years, several combinatorial problems were introduced in the area of access control. Typically, such problems deal with an authorization policy, seen as a relation $UR \subseteq U \times R$, where $(u, r) \in UR$ means that user $u$ is authorized to access resource $r$. Li, Tripunitara and Wang (2009) introduced the Resiliency Checking Problem (RCP), in which we are given an authorization policy, a subset of resources $P \subseteq R$, as well as integers $s \ge 0$, $d \ge 1$ and $t \geq 1$. It asks whether upon removal of any set of at most $s$ users, there still exist $d$ pairwise disjoint sets of at most $t$ users such that each set has collectively access to all resources in $P$. This problem possesses several parameters which appear to take small values in practice. We thus analyze the parameterized complexity of RCP with respect to these parameters, by considering all possible combinations of $|P|, s, d, t$. In all but one case, we are able to settle whether the problem is in FPT, XP, W[2]-hard, para-NP-hard or para-coNP-hard. We also consider the restricted case where $s=0$ for which we determine the complexity for all possible combinations of the parameters

Polynomial Kernels for Weighted Problems

Kernelization is a formalization of efficient preprocessing for NP-hard problems using the framework of parameterized complexity. Among open problems in kernelization it has been asked many times whether there are deterministic polynomial kernelizations for Subset Sum and Knapsack when parameterized by the number $n$ of items. We answer both questions affirmatively by using an algorithm for compressing numbers due to Frank and Tardos (Combinatorica 1987). This result had been first used by Marx and V\'egh (ICALP 2013) in the context of kernelization. We further illustrate its applicability by giving polynomial kernels also for weighted versions of several well-studied parameterized problems. Furthermore, when parameterized by the different item sizes we obtain a polynomial kernelization for Subset Sum and an exponential kernelization for Knapsack. Finally, we also obtain kernelization results for polynomial integer programs

A Subfield Lattice Attack on Overstretched NTRU Assumptions:Cryptanalysis of Some FHE and Graded Encoding Schemes

International audienc

Parameterized Complexity of Maximum Edge Colorable Subgraph

A graph $H$ is {\em $p$-edge colorable} if there is a coloring $\psi: E(H) \rightarrow \{1,2,\dots,p\}$, such that for distinct $uv, vw \in E(H)$, we have $\psi(uv) \neq \psi(vw)$. The {\sc Maximum Edge-Colorable Subgraph} problem takes as input a graph $G$ and integers $l$ and $p$, and the objective is to find a subgraph $H$ of $G$ and a $p$-edge-coloring of $H$, such that $|E(H)| \geq l$. We study the above problem from the viewpoint of Parameterized Complexity. We obtain \FPT\ algorithms when parameterized by: $(1)$ the vertex cover number of $G$, by using {\sc Integer Linear Programming}, and $(2)$ $l$, a randomized algorithm via a reduction to \textsc{Rainbow Matching}, and a deterministic algorithm by using color coding, and divide and color. With respect to the parameters $p+k$, where $k$ is one of the following: $(1)$ the solution size, $l$, $(2)$ the vertex cover number of $G$, and $(3)$ l - {\mm}(G), where {\mm}(G) is the size of a maximum matching in $G$; we show that the (decision version of the) problem admits a kernel with $\mathcal{O}(k \cdot p)$ vertices. Furthermore, we show that there is no kernel of size $\mathcal{O}(k^{1-\epsilon} \cdot f(p))$, for any $\epsilon > 0$ and computable function $f$, unless \NP \subseteq \CONPpoly

Slide reduction, revisited—filling the gaps in svp approximation

We show how to generalize Gama and Nguyen's slide reduction algorithm [STOC '08] for solving the approximate Shortest Vector Problem over lattices (SVP). As a result, we show the fastest provably correct algorithm for $\delta$-approximate SVP for all approximation factors $n^{1/2+\varepsilon} \leq \delta \leq n^{O(1)}$. This is the range of approximation factors most relevant for cryptography

Online Algorithms on Antipowers and Antiperiods

The definition of antipower introduced by Fici et al. (ICALP 2016) captures the notion of being the opposite of a power: a sequence of k pairwise distinct blocks of the same length. Recently, Alamro et al. (CPM 2019) defined a string to have an antiperiod if it is a prefix of an antipower, and gave complexity bounds for the offline computation of the minimum antiperiod and all the antiperiods of a word. In this paper, we address the same problems in the online setting. Our solutions rely on new arrays that compactly and incrementally store antiperiods and antipowers as the word grows, obtaining in the process this information for all the word’s prefixes. We show how to compute those arrays online in O(n log n) space, O(n log n) time, and o(n^epsilon) delay per character, for any constant epsilon > 0. Running times are worst-case and hold with high probability. We also discuss more space-efficient solutions returning the correct result with high probability, and small data structures to support random access to those arrays