Publications

We consider the problem of selecting a committee of $k$ alternatives among
$m$ alternatives, based on the ordinal rank list of voters. Our focus is on the
case where both voters and alternatives lie on a metric space-specifically, on
the line-and the objective is to minimize the additive social cost. The
additive social cost is the sum of the costs for all voters, where the cost for
each voter is defined as the sum of their distances to each member of the
selected committee.
We propose a new voting rule, the Polar Comparison Rule, which achieves upper
bounds of $1 + \sqrt{2} \approx 2.41$ and $7/3 \approx 2.33$ distortions for $k
= 2$ and $k = 3$, respectively, and we show that these bounds are tight.
Furthermore, we generalize this rule, showing that it maintains a distortion of
roughly $7/3$ based on the remainder of the committee size when divided by
three. We also establish lower bounds on the achievable distortion based on the
parity of $k$ and for both small and large committee sizes.

We consider the problem of selecting a committee of $k$ alternatives among
$m$ alternatives, based on the ordinal rank list of voters. Our focus is on the
case where both voters and alternatives lie on a metric space-specifically, on
the line-and the objective is to minimize the additive social cost. The
additive social cost is the sum of the costs for all voters, where the cost for
each voter is defined as the sum of their distances to each member of the
selected committee.
We propose a new voting rule, the Polar Comparison Rule, which achieves upper
bounds of $1 + \sqrt{2} \approx 2.41$ and $7/3 \approx 2.33$ distortions for $k
= 2$ and $k = 3$, respectively, and we show that these bounds are tight.
Furthermore, we generalize this rule, showing that it maintains a distortion of
roughly $7/3$ based on the remainder of the committee size when divided by
three. We also establish lower bounds on the achievable distortion based on the
parity of $k$ and for both small and large committee sizes.

A central result of Marx [ToC '10] proves that there are $k$-vertex graphs
$H$ of maximum degree $3$ such that $n^{o(k /\log k)}$ time algorithms for
detecting colorful $H$-subgraphs would refute the Exponential-Time Hypothesis
(ETH). This result is widely used to obtain almost-tight conditional lower
bounds for parameterized problems under ETH.
Our first contribution is a new and fully self-contained proof of this result
that further simplifies a recent work by Karthik et al. [SOSA 2024]. Towards
this end, we introduce a novel graph parameter, the linkage capacity
$\gamma(H)$, and show with an elementary proof that detecting colorful
$H$-subgraphs in time $n^{o(\gamma(H))}$ refutes ETH. Then, we use a simple
construction of communication networks credited to Bene\v{s} to obtain
$k$-vertex graphs of maximum degree $3$ and linkage capacity $\Omega(k / \log
k)$, avoiding the use of expander graphs. We also show that every graph $H$ of
treewidth $t$ has linkage capacity $\Omega(t / \log t)$, thus recovering the
stronger result of Marx [ToC '10] with a simplified proof.
Additionally, we obtain new tight lower bounds for certain types of patterns
by analyzing their linkage capacity. For example, we prove that almost all
$k$-vertex graphs of polynomial average degree $\Omega(k^{\beta})$ for some
$\beta > 0$ have linkage capacity $\Theta(k)$, which implies tight lower bounds
for such patterns $H$. As an application of these results, we also obtain tight
lower bounds for counting small induced subgraphs having a certain property
$\Phi$, improving bounds from [Roth et al., FOCS 2020].

The Unbounded Subset Sum (USS) problem is an NP-hard computational problem
where the goal is to decide whether there exist non-negative integers $x_1,
\ldots, x_n$ such that $x_1 a_1 + \ldots + x_n a_n = b$, where $a_1 < \cdots <
a_n < b$ are distinct positive integers with $\text{gcd}(a_1, \ldots, a_n)$
dividing $b$. The problem can be solved in pseudopolynomial time, while
specialized cases, such as when $b$ exceeds the Frobenius number of $a_1,
\ldots, a_n$ simplify to a total problem where a solution always exists.
This paper explores the concept of totality in USS. The challenge in this
setting is to actually find a solution, even though we know its existence is
guaranteed. We focus on the instances of USS where solutions are guaranteed for
large $b$. We show that when $b$ is slightly greater than the Frobenius number,
we can find the solution to USS in polynomial time.
We then show how our results extend to Integer Programming with Equalities
(ILPE), highlighting conditions under which ILPE becomes total. We investigate
the diagonal Frobenius number, which is the appropriate generalization of the
Frobenius number to this context. In this setting, we give a polynomial-time
algorithm to find a solution of ILPE. The bound obtained from our algorithmic
procedure for finding a solution almost matches the recent existential bound of
Bach, Eisenbrand, Rothvoss, and Weismantel (2024).

We study the problem of allocating a set of indivisible goods among a set of
agents with \emph{2-value additive valuations}. In this setting, each good is
valued either $1$ or $\sfrac{p}{q}$, for some fixed co-prime numbers $p,q\in
\NN$ such that $1\leq q < p$. Our goal is to find an allocation maximizing the
\emph{Nash social welfare} (\NSW), i.e., the geometric mean of the valuations
of the agents. In this work, we give a complete characterization of
polynomial-time tractability of \NSW\ maximization that solely depends on the
values of $q$.
We start by providing a rather simple polynomial-time algorithm to find a
maximum \NSW\ allocation when the valuation functions are \emph{integral}, that
is, $q=1$. We then exploit more involved techniques to get an algorithm
producing a maximum \NSW\ allocation for the \emph{half-integral} case, that
is, $q=2$. Finally, we show it is \classNP-hard to compute an allocation with
maximum \NSW\ whenever $q\geq3$.

We prove a robust contraction decomposition theorem for $H$-minor-free
graphs, which states that given an $H$-minor-free graph $G$ and an integer $p$,
one can partition in polynomial time the vertices of $G$ into $p$ sets
$Z_1,\dots,Z_p$ such that $\operatorname{tw}(G/(Z_i \setminus Z')) = O(p +
|Z'|)$ for all $i \in [p]$ and $Z' \subseteq Z_i$. Here,
$\operatorname{tw}(\cdot)$ denotes the treewidth of a graph and $G/(Z_i
\setminus Z')$ denotes the graph obtained from $G$ by contracting all edges
with both endpoints in $Z_i \setminus Z'$.
Our result generalizes earlier results by Klein [SICOMP 2008] and Demaine et
al. [STOC 2011] based on partitioning $E(G)$, and some recent theorems for
planar graphs by Marx et al. [SODA 2022], for bounded-genus graphs (more
generally, almost-embeddable graphs) by Bandyapadhyay et al. [SODA 2022], and
for unit-disk graphs by Bandyapadhyay et al. [SoCG 2022].
The robust contraction decomposition theorem directly results in
parameterized algorithms with running time $2^{\widetilde{O}(\sqrt{k})} \cdot
n^{O(1)}$ or $n^{O(\sqrt{k})}$ for every vertex/edge deletion problems on
$H$-minor-free graphs that can be formulated as Permutation CSP Deletion or
2-Conn Permutation CSP Deletion. Consequently, we obtain the first
subexponential-time parameterized algorithms for Subset Feedback Vertex Set,
Subset Odd Cycle Transversal, Subset Group Feedback Vertex Set, 2-Conn
Component Order Connectivity on $H$-minor-free graphs. For other problems which
already have subexponential-time parameterized algorithms on $H$-minor-free
graphs (e.g., Odd Cycle Transversal, Vertex Multiway Cut, Vertex Multicut,
etc.), our theorem gives much simpler algorithms of the same running time.

Co-lex partial orders were recently introduced in (Cotumaccio et al., SODA
2021 and JACM 2023) as a powerful tool to index finite state automata, with
applications to regular expression matching. They generalize Wheeler orders
(Gagie et al., Theoretical Computer Science 2017) and naturally reflect the
co-lexicographic order of the strings labeling source-to-node paths in the
automaton. Briefly, the co-lex width $p$ of a finite-state automaton measures
how sortable its states are with respect to the co-lex order among the strings
they accept. Automata of co-lex width $p$ can be compressed to $O(\log p)$ bits
per edge and admit regular expression matching algorithms running in time
proportional to $p^2$ per matched character.
The deterministic co-lex width of a regular language $\mathcal L$ is the
smallest width of such a co-lex order, among all DFAs recognizing $\mathcal L$.
Since languages of small co-lex width admit efficient solutions to automata
compression and pattern matching, computing the co-lex width of a language is
relevant in these applications. The paper introducing co-lex orders determined
that the deterministic co-lex width $p$ of a language $\mathcal L$ can be
computed in time proportional to $m^{O(p)}$, given as input any DFA $\mathcal
A$ for $\mathcal L$, of size (number of transitions) $m =|\mathcal A|$.
In this paper, using new techniques, we show that it is possible to decide in
$O(m^p)$ time if the deterministic co-lex width of the language recognized by a
given minimum DFA is strictly smaller than some integer $p\ge 2$. We complement
this upper bound with a matching conditional lower bound based on the Strong
Exponential Time Hypothesis. The problem is known to be PSPACE-complete when
the input is an NFA (D'Agostino et al., Theoretical Computer Science 2023);
thus, together with that result, our paper essentially settles the complexity
of the problem.

Union volume estimation is a classical algorithmic problem. Given a family of
objects $O_1,\ldots,O_n \subseteq \mathbb{R}^d$, we want to approximate the
volume of their union. In the special case where all objects are boxes (also
known as hyperrectangles) this is known as Klee's measure problem. The
state-of-the-art algorithm [Karp, Luby, Madras '89] for union volume estimation
and Klee's measure problem in constant dimension $d$ computes a
$(1+\varepsilon)$-approximation with constant success probability by using a
total of $O(n/\varepsilon^2)$ queries of the form (i) ask for the volume of
$O_i$, (ii) sample a point uniformly at random from $O_i$, and (iii) query
whether a given point is contained in $O_i$.
We show that if one can only interact with the objects via the aforementioned
three queries, the query complexity of [Karp, Luby, Madras '89] is indeed
optimal, i.e., $\Omega(n/\varepsilon^2)$ queries are necessary. Our lower bound
already holds for estimating the union of equiponderous axis-aligned polygons
in $\mathbb{R}^2$, and even if the algorithm is allowed to inspect the
coordinates of the points sampled from the polygons, and still holds when a
containment query can ask containment of an arbitrary (not sampled) point.
Guided by the insights of the lower bound, we provide a more efficient
approximation algorithm for Klee's measure problem improving the
$O(n/\varepsilon^2)$ time to $O((n+\frac{1}{\varepsilon^2}) \cdot
\log^{O(d)}n)$. We achieve this improvement by exploiting the geometry of
Klee's measure problem in various ways: (1) Since we have access to the boxes'
coordinates, we can split the boxes into classes of boxes of similar shape. (2)
Within each class, we show how to sample from the union of all boxes, by using
orthogonal range searching. And (3) we exploit that boxes of different classes
have small intersection, for most pairs of classes.

Constrained Forest Problems (CFPs) as introduced by Goemans and Williamson in
1995 capture a wide range of network design problems with edge subsets as
solutions, such as Minimum Spanning Tree, Steiner Forest, and Point-to-Point
Connection. While individual CFPs have been studied extensively in individual
computational models, a unified approach to solving general CFPs in multiple
computational models has been lacking. Against this background, we present the
shell-decomposition algorithm, a model-agnostic meta-algorithm that efficiently
computes a $(2+\epsilon)$-approximation to CFPs for a broad class of forest
functions. To demonstrate the power and flexibility of this result, we
instantiate our algorithm for 3 fundamental, NP-hard CFPs in 3 different
computational models. For example, for constant $\epsilon$, we obtain the
following $(2+\epsilon)$-approximations in the Congest model:
1. For Steiner Forest specified via input components, where each node knows
the identifier of one of $k$ disjoint subsets of $V$, we achieve a
deterministic $(2+\epsilon)$-approximation in $O(\sqrt{n}+D+k)$ rounds, where
$D$ is the hop diameter of the graph.
2. For Steiner Forest specified via symmetric connection requests, where
connection requests are issued to pairs of nodes, we leverage randomized
equality testing to reduce the running time to $O(\sqrt{n}+D)$, succeeding with
high probability.
3. For Point-to-Point Connection, we provide a $(2+\epsilon)$-approximation
in $O(\sqrt{n}+D)$ rounds.
4. For Facility Placement and Connection, a relative of non-metric Facility
Location, we obtain a $(2+\epsilon)$-approximation in $O(\sqrt{n}+D)$ rounds.
We further show how to replace the $\sqrt{n}+D$ term by the complexity of
solving Partwise Aggregation, achieving (near-)universal optimality in any
setting in which a solution to Partwise Aggregation in near-shortcut-quality
time is known.

The task of min-plus matrix multiplication often arises in the context of
distances in graphs and is known to be fine-grained equivalent to the All-Pairs
Shortest Path problem. The non-crossing property of shortest paths in planar
graphs gives rise to Monge matrices; the min-plus product of $n\times n$ Monge
matrices can be computed in $O(n^2)$ time. Grid graphs arising in sequence
alignment problems, such as longest common subsequence or longest increasing
subsequence, are even more structured. Tiskin [SODA'10] modeled their behavior
using simple unit-Monge matrices and showed that the min-plus product of such
matrices can be computed in $O(n\log n)$ time. Russo [SPIRE'11] showed that the
min-plus product of arbitrary Monge matrices can be computed in time
$O((n+\delta)\log^3 n)$ parameterized by the core size $\delta$, which is
$O(n)$ for unit-Monge matrices.
In this work, we provide a linear bound on the core size of the product
matrix in terms of the core sizes of the input matrices and show how to solve
the core-sparse Monge matrix multiplication problem in $O((n+\delta)\log n)$
time, matching the result of Tiskin for simple unit-Monge matrices. Our
algorithm also allows $O(\log \delta)$-time witness recovery for any given
entry of the output matrix. As an application of this functionality, we show
that an array of size $n$ can be preprocessed in $O(n\log^3 n)$ time so that
the longest increasing subsequence of any sub-array can be reconstructed in
$O(l)$ time, where $l$ is the length of the reported subsequence; in
comparison, Karthik C. S. and Rahul [arXiv'24] recently achieved
$O(l+n^{1/2}\log^3 n)$-time reporting after $O(n^{3/2}\log^3 n)$-time
preprocessing. Our faster core-sparse Monge matrix multiplication also enabled
reducing two logarithmic factors in the running times of the recent algorithms
for edit distance with integer weights [Gorbachev & Kociumaka, arXiv'24].

The edit distance of two strings is the minimum number of insertions,
deletions, and substitutions needed to transform one string into the other. The
textbook algorithm determines the edit distance of length-$n$ strings in
$O(n^2)$ time, which is optimal up to subpolynomial factors under Orthogonal
Vectors Hypothesis. In the bounded version of the problem, parameterized by the
edit distance $k$, the algorithm of Landau and Vishkin [JCSS'88] achieves
$O(n+k^2)$ time, which is optimal as a function of $n$ and $k$.
The dynamic version of the problem asks to maintain the edit distance of two
strings that change dynamically, with each update modeled as an edit. A
folklore approach supports updates in $\tilde O(k^2)$ time, where $\tilde
O(\cdot)$ hides polylogarithmic factors. Recently, Charalampopoulos, Kociumaka,
and Mozes [CPM'20] showed an algorithm with update time $\tilde O(n)$, which is
optimal under OVH in terms of $n$. The update time of $\tilde O(\min\{n,k^2\})$
raised an exciting open question of whether $\tilde O(k)$ is possible; we
answer it affirmatively.
Our solution relies on tools originating from weighted edit distance, where
the weight of each edit depends on the edit type and the characters involved.
The textbook algorithm supports weights, but the Landau-Vishkin approach does
not, and a simple $O(nk)$-time procedure long remained the fastest for bounded
weighted edit distance. Only recently, Das et al. [STOC'23] provided an
$O(n+k^5)$-time algorithm, whereas Cassis, Kociumaka, and Wellnitz [FOCS'23]
presented an $\tilde O(n+\sqrt{nk^3})$-time solution and a matching conditional
lower bound. In this paper, we show that, for integer edit weights between $0$
and $W$, weighted edit distance can be computed in $\tilde O(n+Wk^2)$ time and
maintained dynamically in $\tilde O(W^2k)$ time per update. Our static
algorithm can also be implemented in $\tilde O(n+k^{2.5})$ time.

Lagarias and Odlyzko (J.~ACM~1985) proposed a polynomial time algorithm for
solving ``\emph{almost all}'' instances of the Subset Sum problem with $n$
integers of size $\Omega(\Gamma_{\text{LO}})$, where
$\log_2(\Gamma_{\text{LO}}) > n^2 \log_2(\gamma)$ and $\gamma$ is a parameter
of the lattice basis reduction ($\gamma > \sqrt{4/3}$ for LLL). The algorithm
of Lagarias and Odlyzko is a cornerstone result in cryptography. However, the
theoretical guarantee on the density of feasible instances has remained
unimproved for almost 40 years.
In this paper, we propose an algorithm to solve ``almost all'' instances of
Subset Sum with integers of size $\Omega(\sqrt{\Gamma_{\text{LO}}})$ after a
single call to the lattice reduction. Additionally, our argument allows us to
solve the Subset Sum problem for multiple targets while the previous approach
could only answer one target per call to lattice basis reduction. We introduce
a modular arithmetic approach to the Subset Sum problem. The idea is to use the
lattice reduction to solve a linear system modulo a suitably large prime. We
show that density guarantees can be improved, by analysing the lengths of the
LLL reduced basis vectors, of both the primal and the dual lattices
simultaneously.

Integer linear programs $\min\{c^T x : A x = b, x \in \mathbb{Z}^n_{\ge
0}\}$, where $A \in \mathbb{Z}^{m \times n}$, $b \in \mathbb{Z}^m$, and $c \in
\mathbb{Z}^n$, can be solved in pseudopolynomial time for any fixed number of
constraints $m = O(1)$. More precisely, in time $(m\Delta)^{O(m)}
\text{poly}(I)$, where $\Delta$ is the maximum absolute value of an entry in
$A$ and $I$ the input size.
Known algorithms rely heavily on dynamic programming, which leads to a space
complexity of similar order of magnitude as the running time. In this paper, we
present a polynomial space algorithm that solves integer linear programs in
$(m\Delta)^{O(m (\log m + \log\log\Delta))} \text{poly}(I)$ time, that is, in
almost the same time as previous dynamic programming algorithms.

This paper presents parallel and distributed algorithms for single-source
shortest paths when edges can have negative weights (negative-weight SSSP). We
show a framework that reduces negative-weight SSSP in either setting to
$n^{o(1)}$ calls to any SSSP algorithm that works with a virtual source. More
specifically, for a graph with $m$ edges, $n$ vertices, undirected hop-diameter
$D$, and polynomially bounded integer edge weights, we show randomized
algorithms for negative-weight SSSP with (i) $W_{SSSP}(m,n)n^{o(1)}$ work and
$S_{SSSP}(m,n)n^{o(1)}$ span, given access to an SSSP algorithm with
$W_{SSSP}(m,n)$ work and $S_{SSSP}(m,n)$ span in the parallel model, (ii)
$T_{SSSP}(n,D)n^{o(1)}$, given access to an SSSP algorithm that takes
$T_{SSSP}(n,D)$ rounds in $\mathsf{CONGEST}$. This work builds off the recent
result of [Bernstein, Nanongkai, Wulff-Nilsen, FOCS'22], which gives a
near-linear time algorithm for negative-weight SSSP in the sequential setting.
Using current state-of-the-art SSSP algorithms yields randomized algorithms
for negative-weight SSSP with (i) $m^{1+o(1)}$ work and $n^{1/2+o(1)}$ span in
the parallel model, (ii) $(n^{2/5}D^{2/5} + \sqrt{n} + D)n^{o(1)}$ rounds in
$\mathsf{CONGEST}$.
Our main technical contribution is an efficient reduction for computing a
low-diameter decomposition (LDD) of directed graphs to computations of SSSP
with a virtual source. Efficiently computing an LDD has heretofore only been
known for undirected graphs in both the parallel and distributed models. The
LDD is a crucial step of the algorithm in [Bernstein, Nanongkai, Wulff-Nilsen,
FOCS'22], and we think that its applications to other problems in parallel and
distributed models are far from being exhausted.

We present a randomized algorithm that computes single-source shortest paths
(SSSP) in $O(m\log^8(n)\log W)$ time when edge weights are integral and can be
negative. This essentially resolves the classic negative-weight SSSP problem.
The previous bounds are $\tilde O((m+n^{1.5})\log W)$ [BLNPSSSW FOCS'20] and
$m^{4/3+o(1)}\log W$ [AMV FOCS'20]. Near-linear time algorithms were known
previously only for the special case of planar directed graphs [Fakcharoenphol
and Rao FOCS'01].
In contrast to all recent developments that rely on sophisticated continuous
optimization methods and dynamic algorithms, our algorithm is simple: it
requires only a simple graph decomposition and elementary combinatorial tools.
In fact, ours is the first combinatorial algorithm for negative-weight SSSP to
break through the classic $\tilde O(m\sqrt{n}\log W)$ bound from over three
decades ago [Gabow and Tarjan SICOMP'89].

We show a fully dynamic algorithm for maintaining $(1+\epsilon)$-approximate
\emph{size} of maximum matching of the graph with $n$ vertices and $m$ edges
using $m^{0.5-\Omega_{\epsilon}(1)}$ update time. This is the first polynomial
improvement over the long-standing $O(n)$ update time, which can be trivially
obtained by periodic recomputation. Thus, we resolve the value version of a
major open question of the dynamic graph algorithms literature (see, e.g.,
[Gupta and Peng FOCS'13], [Bernstein and Stein SODA'16],[Behnezhad and Khanna
SODA'22]).
Our key technical component is the first sublinear algorithm for $(1,\epsilon
n)$-approximate maximum matching with sublinear running time on dense graphs.
All previous algorithms suffered a multiplicative approximation factor of at
least $1.499$ or assumed that the graph has a very small maximum degree.

In the dynamic approximate maximum bipartite matching problem we are given
bipartite graph $G$ undergoing updates and our goal is to maintain a matching
of $G$ which is large compared the maximum matching size $\mu(G)$. We define a
dynamic matching algorithm to be $\alpha$ (respectively $(\alpha,
\beta)$)-approximate if it maintains matching $M$ such that at all times $|M |
\geq \mu(G) \cdot \alpha$ (respectively $|M| \geq \mu(G) \cdot \alpha -
\beta$).
We present the first deterministic $(1-\epsilon )$-approximate dynamic
matching algorithm with $O(poly(\epsilon ^{-1}))$ amortized update time for
graphs undergoing edge insertions. Previous solutions either required
super-constant [Gupta FSTTCS'14, Bhattacharya-Kiss-Saranurak SODA'23] or
exponential in $1/\epsilon $
[Grandoni-Leonardi-Sankowski-Schwiegelshohn-Solomon SODA'19] update time. Our
implementation is arguably simpler than the mentioned algorithms and its
description is self contained. Moreover, we show that if we allow for additive
$(1, \epsilon \cdot n)$-approximation our algorithm seamlessly extends to also
handle vertex deletions, on top of edge insertions. This makes our algorithm
one of the few small update time algorithms for $(1-\epsilon )$-approximate
dynamic matching allowing for updates both increasing and decreasing the
maximum matching size of $G$ in a fully dynamic manner.

Bridging geometry and topology, curvature is a powerful and expressive invariant. While the utility of curvature has been theoretically and empirically confirmed in the context of manifolds and graphs, its generalization to the emerging domain of hypergraphs has remained largely unexplored. On graphs, Ollivier-Ricci curvature measures differences between random walks via Wasserstein distances, thus grounding a geometric concept in ideas from probability and optimal transport. We develop ORCHID, a flexible framework generalizing Ollivier-Ricci curvature to hypergraphs, and prove that the resulting curvatures have favorable theoretical properties. Through extensive experiments on synthetic and real-world hypergraphs from different domains, we demonstrate that ORCHID curvatures are both scalable and useful to perform a variety of hypergraph tasks in practice.

The notion of Las Vegas algorithm was introduced by Babai (1979) and may be
defined in two ways:
* In Babai's original definition, a randomized algorithm is called Las Vegas
if it has finitely bounded running time and certifiable random failure.
* Alternatively, in a widely accepted definition today, Las Vegas algorithms
mean the zero-error randomized algorithms with random running time.
The equivalence between the two definitions is straightforward. In
particular, by repeatedly running the algorithm until no failure encountered,
one can simulate the correct output of a successful running.
We show that this can also be achieved for distributed local computation.
Specifically, we show that in the LOCAL model, any Las Vegas algorithm that
terminates in finite time with locally certifiable failures, can be converted
to a zero-error Las Vegas algorithm, at a polylogarithmic cost in the time
complexity, such that the resulting algorithm perfectly simulates the output of
the original algorithm on the same instance conditioned on that the algorithm
successfully returns without failure.

We introduce a new algorithm and software for solving linear equations in
symmetric diagonally dominant matrices with non-positive off-diagonal entries
(SDDM matrices), including Laplacian matrices. We use pre-conditioned conjugate
gradient (PCG) to solve the system of linear equations. Our preconditioner is a
variant of the Approximate Cholesky factorization of Kyng and Sachdeva (FOCS
2016). Our factorization approach is simple: we eliminate matrix rows/columns
one at a time and update the remaining matrix using sampling to approximate the
outcome of complete Cholesky factorization. Unlike earlier approaches, our
sampling always maintains a connectivity in the remaining non-zero structure.
Our algorithm comes with a tuning parameter that upper bounds the number of
samples made per original entry. We implement our algorithm in Julia, providing
two versions, AC and AC2, that respectively use 1 and 2 samples per original
entry. We compare their single-threaded performance to that of current
state-of-the-art solvers Combinatorial Multigrid (CMG),
BoomerAMG-preconditioned Krylov solvers from HyPre and PETSc, Lean Algebraic
Multigrid (LAMG), and MATLAB's with Incomplete Cholesky Factorization (ICC).
Our evaluation uses a broad class of problems, including all large SDDM
matrices from the SuiteSparse collection and diverse programmatically generated
instances. Our experiments suggest that our algorithm attains a level of
robustness and reliability not seen before in SDDM solvers, while retaining
good performance across all instances. Our code and data are public, and we
provide a tutorial on how to replicate our tests. We hope that others will
adopt this suite of tests as a benchmark, which we refer to as SDDM2023. Our
solver code is available at: github.com/danspielman/Laplacians.jl/ Our
benchmarking data and tutorial are available at:
rjkyng.github.io/SDDM2023/

Dot-product attention mechanism plays a crucial role in modern deep
architectures (e.g., Transformer) for sequence modeling, however, na\"ive exact
computation of this model incurs quadratic time and memory complexities in
sequence length, hindering the training of long-sequence models. Critical
bottlenecks are due to the computation of partition functions in the
denominator of softmax function as well as the multiplication of the softmax
matrix with the matrix of values. Our key observation is that the former can be
reduced to a variant of the kernel density estimation (KDE) problem, and an
efficient KDE solver can be further utilized to accelerate the latter via
subsampling-based fast matrix products. Our proposed KDEformer can approximate
the attention in sub-quadratic time with provable spectral norm bounds, while
all prior results merely provide entry-wise error bounds. Empirically, we
verify that KDEformer outperforms other attention approximations in terms of
accuracy, memory, and runtime on various pre-trained models. On BigGAN image
generation, we achieve better generative scores than the exact computation with
over $4\times$ speedup. For ImageNet classification with T2T-ViT, KDEformer
shows over $18\times$ speedup while the accuracy drop is less than $0.5\%$.

The existence of EFX allocations is a fundamental open problem in discrete
fair division. Given a set of agents and indivisible goods, the goal is to
determine the existence of an allocation where no agent envies another
following the removal of any single good from the other agent's bundle. Since
the general problem has been illusive, progress is made on two fronts: $(i)$
proving existence when the number of agents is small, $(ii)$ proving existence
of relaxations of EFX. In this paper, we improve results on both fronts (and
simplify in one of the cases).
We prove the existence of EFX allocations with three agents, restricting only
one agent to have an MMS-feasible valuation function (a strict generalization
of nice-cancelable valuation functions introduced by Berger et al. which
subsumes additive, budget-additive and unit demand valuation functions). The
other agents may have any monotone valuation functions. Our proof technique is
significantly simpler and shorter than the proof by Chaudhury et al. on
existence of EFX allocations when there are three agents with additive
valuation functions and therefore more accessible.
Secondly, we consider relaxations of EFX allocations, namely, approximate-EFX
allocations and EFX allocations with few unallocated goods (charity). Chaudhury
et al. showed the existence of $(1-\epsilon)$-EFX allocation with
$O((n/\epsilon)^{\frac{4}{5}})$ charity by establishing a connection to a
problem in extremal combinatorics. We improve their result and prove the
existence of $(1-\epsilon)$-EFX allocations with $\tilde{O}((n/
\epsilon)^{\frac{1}{2}})$ charity. In fact, some of our techniques can be used
to prove improved upper-bounds on a problem in zero-sum combinatorics
introduced by Alon and Krivelevich.

We consider the problem of maximizing the Nash social welfare when allocating
a set $G$ of indivisible goods to a set $N$ of agents. We study instances, in
which all agents have 2-value additive valuations: The value of a good $g \in
G$ for an agent $i \in N$ is either $1$ or $s$, where $s$ is an odd multiple of
$\frac{1}{2}$ larger than one. We show that the problem is solvable in
polynomial time. Akrami et at. showed that this problem is solvable in
polynomial time if $s$ is integral and is NP-hard whenever $s = \frac{p}{q}$,
$p \in \mathbb{N}$ and $q\in \mathbb{N}$ are co-prime and $p > q \ge 3$. For
the latter situation, an approximation algorithm was also given. It obtains an
approximation ratio of at most $1.0345$. Moreover, the problem is APX-hard,
with a lower bound of $1.000015$ achieved at $\frac{p}{q} = \frac{5}{4}$. The
case $q = 2$ and odd $p$ was left open.
In the case of integral $s$, the problem is separable in the sense that the
optimal allocation of the heavy goods (= value $s$ for some agent) is
independent of the number of light goods (= value $1$ for all agents). This
leads to an algorithm that first computes an optimal allocation of the heavy
goods and then adds the light goods greedily. This separation no longer holds
for $s = \frac{3}{2}$; a simple example is given in the introduction. Thus an
algorithm has to consider heavy and light goods together. This complicates
matters considerably. Our algorithm is based on a collection of improvement
rules that transfers any allocation into an optimal allocation and exploits a
connection to matchings with parity constraints.

We study the problem of fairly allocating a set of $m$ indivisible goods to a
set of $n$ agents. Envy-freeness up to any good (EFX) criteria -- which
requires that no agent prefers the bundle of another agent after removal of any
single good -- is known to be a remarkable analogous of envy-freeness when the
resource is a set of indivisible goods. In this paper, we investigate EFX
notion for the restricted additive valuations, that is, every good has some
non-negative value, and every agent is interested in only some of the goods.
We introduce a natural relaxation of EFX called EFkX which requires that no
agent envies another agent after removal of any $k$ goods. Our main
contribution is an algorithm that finds a complete (i.e., no good is discarded)
EF2X allocation for the restricted additive valuations. In our algorithm we
devise new concepts, namely "configuration" and "envy-elimination" that might
be of independent interest.
We also use our new tools to find an EFX allocation for restricted additive
valuations that discards at most $\lfloor n/2 \rfloor -1$ goods. This improves
the state of the art for the restricted additive valuations by a factor of $2$.

Given the rapid rise in energy demand by data centers and computing systems
in general, it is fundamental to incorporate energy considerations when
designing (scheduling) algorithms. Machine learning can be a useful approach in
practice by predicting the future load of the system based on, for example,
historical data. However, the effectiveness of such an approach highly depends
on the quality of the predictions and can be quite far from optimal when
predictions are sub-par. On the other hand, while providing a worst-case
guarantee, classical online algorithms can be pessimistic for large classes of
inputs arising in practice.
This paper, in the spirit of the new area of machine learning augmented
algorithms, attempts to obtain the best of both worlds for the classical,
deadline based, online speed-scaling problem: Based on the introduction of a
novel prediction setup, we develop algorithms that (i) obtain provably low
energy-consumption in the presence of adequate predictions, and (ii) are robust
against inadequate predictions, and (iii) are smooth, i.e., their performance
gradually degrades as the prediction error increases.

We study sublinear time algorithms for estimating the size of maximum
matching. After a long line of research, the problem was finally settled by
Behnezhad [FOCS'22], in the regime where one is willing to pay an approximation
factor of $2$. Very recently, Behnezhad et al.[SODA'23] improved the
approximation factor to $(2-\frac{1}{2^{O(1/\gamma)}})$ using $n^{1+\gamma}$
time. This improvement over the factor $2$ is, however, minuscule and they
asked if even $1.99$-approximation is possible in $n^{2-\Omega(1)}$ time. We
give a strong affirmative answer to this open problem by showing
$(1.5+\epsilon)$-approximation algorithms that run in
$n^{2-\Theta(\epsilon^{2})}$ time. Our approach is conceptually simple and
diverges from all previous sublinear-time matching algorithms: we show a
sublinear time algorithm for computing a variant of the edge-degree constrained
subgraph (EDCS), a concept that has previously been exploited in dynamic
[Bernstein Stein ICALP'15, SODA'16], distributed [Assadi et al. SODA'19] and
streaming [Bernstein ICALP'20] settings, but never before in the sublinear
setting. Independent work: Behnezhad, Roghani and Rubinstein [BRR'23]
independently showed sublinear algorithms similar to our Theorem 1.2 in both
adjacency list and matrix models. Furthermore, in [BRR'23], they show
additional results on strictly better-than-1.5 approximate matching algorithms
in both upper and lower bound sides.

The circumference of a graph $G$ is the length of a longest cycle in $G$, or
$+\infty$ if $G$ has no cycle. Birmel\'e (2003) showed that the treewidth of a
graph $G$ is at most its circumference minus one. We strengthen this result for
$2$-connected graphs as follows: If $G$ is $2$-connected, then its treedepth is
at most its circumference. The bound is best possible and improves on an
earlier quadratic upper bound due to Marshall and Wood (2015).

We consider the approximate pattern matching problem under the edit distance.
Given a text $T$ of length $n$, a pattern $P$ of length $m$, and a threshold
$k$, the task is to find the starting positions of all substrings of $T$ that
can be transformed to $P$ with at most $k$ edits. More than 20 years ago, Cole
and Hariharan [SODA'98, J. Comput.'02] gave an $\mathcal{O}(n+k^4 \cdot n/
m)$-time algorithm for this classic problem, and this runtime has not been
improved since.
Here, we present an algorithm that runs in time $\mathcal{O}(n+k^{3.5}
\sqrt{\log m \log k} \cdot n/m)$, thus breaking through this long-standing
barrier. In the case where $n^{1/4+\varepsilon} \leq k \leq
n^{2/5-\varepsilon}$ for some arbitrarily small positive constant
$\varepsilon$, our algorithm improves over the state-of-the-art by polynomial
factors: it is polynomially faster than both the algorithm of Cole and
Hariharan and the classic $\mathcal{O}(kn)$-time algorithm of Landau and
Vishkin [STOC'86, J. Algorithms'89].
We observe that the bottleneck case of the alternative $\mathcal{O}(n+k^4
\cdot n/m)$-time algorithm of Charalampopoulos, Kociumaka, and Wellnitz
[FOCS'20] is when the text and the pattern are (almost) periodic. Our new
algorithm reduces this case to a new dynamic problem (Dynamic Puzzle Matching),
which we solve by building on tools developed by Tiskin [SODA'10,
Algorithmica'15] for the so-called seaweed monoid of permutation matrices. Our
algorithm relies only on a small set of primitive operations on strings and
thus also applies to the fully-compressed setting (where text and pattern are
given as straight-line programs) and to the dynamic setting (where we maintain
a collection of strings under creation, splitting, and concatenation),
improving over the state of the art.

We introduce Hyperbard, a dataset of diverse relational data representations
derived from Shakespeare's plays. Our representations range from simple graphs
capturing character co-occurrence in single scenes to hypergraphs encoding
complex communication settings and character contributions as hyperedges with
edge-specific node weights. By making multiple intuitive representations
readily available for experimentation, we facilitate rigorous representation
robustness checks in graph learning, graph mining, and network analysis,
highlighting the advantages and drawbacks of specific representations.
Leveraging the data released in Hyperbard, we demonstrate that many solutions
to popular graph mining problems are highly dependent on the representation
choice, thus calling current graph curation practices into question. As an
homage to our data source, and asserting that science can also be art, we
present all our points in the form of a play.

We introduce seven foundational principles for creating a culture of
constructive criticism in computational legal studies. Beginning by challenging
the current perception of papers as the primary scholarly output, we call for a
more comprehensive interpretation of publications. We then suggest to make
these publications computationally reproducible, releasing all of the data and
all of the code all of the time, on time, and in the most functioning form
possible. Subsequently, we invite constructive criticism in all phases of the
publication life cycle. We posit that our proposals will help form our field,
and float the idea of marking this maturity by the creation of a modern
flagship publication outlet for computational legal studies.

How does neural connectivity in autistic children differ from neural
connectivity in healthy children or autistic youths? What patterns in global
trade networks are shared across classes of goods, and how do these patterns
change over time? Answering questions like these requires us to differentially
describe groups of graphs: Given a set of graphs and a partition of these
graphs into groups, discover what graphs in one group have in common, how they
systematically differ from graphs in other groups, and how multiple groups of
graphs are related. We refer to this task as graph group analysis, which seeks
to describe similarities and differences between graph groups by means of
statistically significant subgraphs. To perform graph group analysis, we
introduce Gragra, which uses maximum entropy modeling to identify a
non-redundant set of subgraphs with statistically significant associations to
one or more graph groups. Through an extensive set of experiments on a wide
range of synthetic and real-world graph groups, we confirm that Gragra works
well in practice.

We generalize the monotone local search approach of Fomin, Gaspers,
Lokshtanov and Saurabh [J.ACM 2019], by establishing a connection between
parameterized approximation and exponential-time approximation algorithms for
monotone subset minimization problems. In a monotone subset minimization
problem the input implicitly describes a non-empty set family over a universe
of size $n$ which is closed under taking supersets. The task is to find a
minimum cardinality set in this family. Broadly speaking, we use approximate
monotone local search to show that a parameterized $\alpha$-approximation
algorithm that runs in $c^k \cdot n^{O(1)}$ time, where $k$ is the solution
size, can be used to derive an $\alpha$-approximation randomized algorithm that
runs in $d^n \cdot n^{O(1)}$ time, where $d$ is the unique value in $d \in
(1,1+\frac{c-1}{\alpha})$ such that
$\mathcal{D}(\frac{1}{\alpha}\|\frac{d-1}{c-1})=\frac{\ln c}{\alpha}$ and
$\mathcal{D}(a \|b)$ is the Kullback-Leibler divergence. This running time
matches that of Fomin et al. for $\alpha=1$, and is strictly better when
$\alpha >1$, for any $c > 1$. Furthermore, we also show that this result can be
derandomized at the expense of a sub-exponential multiplicative factor in the
running time.
We demonstrate the potential of approximate monotone local search by deriving
new and faster exponential approximation algorithms for Vertex Cover,
$3$-Hitting Set, Directed Feedback Vertex Set, Directed Subset Feedback Vertex
Set, Directed Odd Cycle Transversal and Undirected Multicut. For instance, we
get a $1.1$-approximation algorithm for Vertex Cover with running time $1.114^n
\cdot n^{O(1)}$, improving upon the previously best known $1.1$-approximation
running in time $1.127^n \cdot n^{O(1)}$ by Bourgeois et al. [DAM 2011].

The Edge Multicut problem is a classical cut problem where given an
undirected graph $G$, a set of pairs of vertices $\mathcal{P}$, and a budget
$k$, the goal is to determine if there is a set $S$ of at most $k$ edges such
that for each $(s,t) \in \mathcal{P}$, $G-S$ has no path from $s$ to $t$. Edge
Multicut has been relatively recently shown to be fixed-parameter tractable
(FPT), parameterized by $k$, by Marx and Razgon [SICOMP 2014], and
independently by Bousquet et al. [SICOMP 2018]. In the weighted version of the
problem, called Weighted Edge Multicut one is additionally given a weight
function $\mathtt{wt} : E(G) \to \mathbb{N}$ and a weight bound $w$, and the
goal is to determine if there is a solution of size at most $k$ and weight at
most $w$. Both the FPT algorithms for Edge Multicut by Marx et al. and Bousquet
et al. fail to generalize to the weighted setting. In fact, the weighted
problem is non-trivial even on trees and determining whether Weighted Edge
Multicut on trees is FPT was explicitly posed as an open problem by Bousquet et
al. [STACS 2009]. In this article, we answer this question positively by
designing an algorithm which uses a very recent result by Kim et al. [STOC
2022] about directed flow augmentation as subroutine.
We also study a variant of this problem where there is no bound on the size
of the solution, but the parameter is a structural property of the input, for
example, the number of leaves of the tree. We strengthen our results by stating
them for the more general vertex deletion version.

The leafage of a chordal graph G is the minimum integer l such that G can be
realized as an intersection graph of subtrees of a tree with l leaves. We
consider structural parameterization by the leafage of classical domination and
cut problems on chordal graphs. Fomin, Golovach, and Raymond [ESA 2018,
Algorithmica 2020] proved, among other things, that Dominating Set on chordal
graphs admits an algorithm running in time $2^{O(l^2)} n^{O(1)}$. We present a
conceptually much simpler algorithm that runs in time $2^{O(l)} n^{O(1)}$. We
extend our approach to obtain similar results for Connected Dominating Set and
Steiner Tree. We then consider the two classical cut problems MultiCut with
Undeletable Terminals and Multiway Cut with Undeletable Terminals. We prove
that the former is W[1]-hard when parameterized by the leafage and complement
this result by presenting a simple $n^{O(l)}$-time algorithm. To our surprise,
we find that Multiway Cut with Undeletable Terminals on chordal graphs can be
solved, in contrast, in $n^{O(1)}$-time.

For a graph $G$, a subset $S \subseteq V(G)$ is called a \emph{resolving set}
if for any two vertices $u,v \in V(G)$, there exists a vertex $w \in S$ such
that $d(w,u) \neq d(w,v)$. The {\sc Metric Dimension} problem takes as input a
graph $G$ and a positive integer $k$, and asks whether there exists a resolving
set of size at most $k$. This problem was introduced in the 1970s and is known
to be NP-hard~[GT~61 in Garey and Johnson's book]. In the realm of
parameterized complexity, Hartung and Nichterlein~[CCC~2013] proved that the
problem is W[2]-hard when parameterized by the natural parameter $k$. They also
observed that it is FPT when parameterized by the vertex cover number and asked
about its complexity under \emph{smaller} parameters, in particular the
feedback vertex set number. We answer this question by proving that {\sc Metric
Dimension} is W[1]-hard when parameterized by the feedback vertex set number.
This also improves the result of Bonnet and Purohit~[IPEC 2019] which states
that the problem is W[1]-hard parameterized by the treewidth. Regarding the
parameterization by the vertex cover number, we prove that {\sc Metric
Dimension} does not admit a polynomial kernel under this parameterization
unless $NP\subseteq coNP/poly$. We observe that a similar result holds when the
parameter is the distance to clique. On the positive side, we show that {\sc
Metric Dimension} is FPT when parameterized by either the distance to cluster
or the distance to co-cluster, both of which are smaller parameters than the
vertex cover number.

In the Directed Steiner Network problem, the input is a directed graph G, a
subset T of k vertices of G called the terminals, and a demand graph D on T.
The task is to find a subgraph H of G with the minimum number of edges such
that for every edge (s,t) in D, the solution H contains a directed s to t path.
In this paper we investigate how the complexity of the problem depends on the
demand pattern when G is planar. Formally, if \mathcal{D} is a class of
directed graphs closed under identification of vertices, then the
\mathcal{D}-Steiner Network (\mathcal{D}-SN) problem is the special case where
the demand graph D is restricted to be from \mathcal{D}. For general graphs,
Feldmann and Marx [ICALP 2016] characterized those families of demand graphs
where the problem is fixed-parameter tractable (FPT) parameterized by the
number k of terminals. They showed that if \mathcal{D} is a superset of one of
the five hard families, then \mathcal{D}-SN is W[1]-hard parameterized by k,
otherwise it can be solved in time f(k)n^{O(1)}.
For planar graphs an interesting question is whether the W[1]-hard cases can
be solved by subexponential parameterized algorithms. Chitnis et al. [SICOMP
2020] showed that, assuming the ETH, there is no f(k)n^{o(k)} time algorithm
for the general \mathcal{D}-SN problem on planar graphs, but the special case
called Strongly Connected Steiner Subgraph can be solved in time f(k)
n^{O(\sqrt{k})} on planar graphs. We present a far-reaching generalization and
unification of these two results: we give a complete characterization of the
behavior of every $\mathcal{D}$-SN problem on planar graphs. We show that
assuming ETH, either the problem is (1) solvable in time 2^{O(k)}n^{O(1)}, and
not in time 2^{o(k)}n^{O(1)}, or (2) solvable in time f(k)n^{O(\sqrt{k})}, but
not in time f(k)n^{o(\sqrt{k})}, or (3) solvable in time f(k)n^{O(k)}, but not
in time f(k)n^{o({k})}.

Physarum Polycephalum is a Slime mold that can solve the shortest path
problem. A mathematical model based on the Physarum's behavior, known as the
Physarum Directed Dynamics, can solve positive linear programs. In this paper,
we will propose a Physarum based dynamic based on the previous work and
introduce a new way to solve positive Semi-Definite Programming (SDP) problems,
which are more general than positive linear programs. Empirical results suggest
that this extension of the dynamic can solve the positive SDP showing that the
nature-inspired algorithm can solve one of the hardest problems in the
polynomial domain. In this work, we will formulate an accurate algorithm to
solve positive and some non-negative SDPs and formally prove some key
characteristics of this solver thus inspiring future work to try and refine
this method.

We study the online Traveling Salesman Problem (TSP) on the line augmented
with machine-learned predictions. In the classical problem, there is a stream
of requests released over time along the real line. The goal is to minimize the
makespan of the algorithm. We distinguish between the open variant and the
closed one, in which we additionally require the algorithm to return to the
origin after serving all requests. The state of the art is a $1.64$-competitive
algorithm and a $2.04$-competitive algorithm for the closed and open variants,
respectively \cite{Bjelde:1.64}. In both cases, a tight lower bound is known
\cite{Ausiello:1.75, Bjelde:1.64}.
In both variants, our primary prediction model involves predicted positions
of the requests. We introduce algorithms that (i) obtain a tight 1.5
competitive ratio for the closed variant and a 1.66 competitive ratio for the
open variant in the case of perfect predictions, (ii) are robust against
unbounded prediction error, and (iii) are smooth, i.e., their performance
degrades gracefully as the prediction error increases.
Moreover, we further investigate the learning-augmented setting in the open
variant by additionally considering a prediction for the last request served by
the optimal offline algorithm. Our algorithm for this enhanced setting obtains
a 1.33 competitive ratio with perfect predictions while also being smooth and
robust, beating the lower bound of 1.44 we show for our original prediction
setting for the open variant. Also, we provide a lower bound of 1.25 for this
enhanced setting.

A mixed graph has a set of vertices, a set of undirected egdes, and a set of
directed arcs. A proper coloring of a mixed graph $G$ is a function $c$ that
assigns to each vertex in $G$ a positive integer such that, for each edge $uv$
in $G$, $c(u) \ne c(v)$ and, for each arc $uv$ in $G$, $c(u) < c(v)$. For a
mixed graph $G$, the chromatic number $\chi(G)$ is the smallest number of
colors in any proper coloring of $G$. A directional interval graph is a mixed
graph whose vertices correspond to intervals on the real line. Such a graph has
an edge between every two intervals where one is contained in the other and an
arc between every two overlapping intervals, directed towards the interval that
starts and ends to the right.
Coloring such graphs has applications in routing edges in layered orthogonal
graph drawing according to the Sugiyama framework; the colors correspond to the
tracks for routing the edges. We show how to recognize directional interval
graphs, and how to compute their chromatic number efficiently. On the other
hand, for mixed interval graphs, i.e., graphs where two intersecting intervals
can be connected by an edge or by an arc in either direction arbitrarily, we
prove that computing the chromatic number is NP-hard.

We show fixed-parameter tractability of the Directed Multicut problem with
three terminal pairs (with a randomized algorithm). This problem, given a
directed graph $G$, pairs of vertices (called terminals) $(s_1,t_1)$,
$(s_2,t_2)$, and $(s_3,t_3)$, and an integer $k$, asks to find a set of at most
$k$ non-terminal vertices in $G$ that intersect all $s_1t_1$-paths, all
$s_2t_2$-paths, and all $s_3t_3$-paths. The parameterized complexity of this
case has been open since Chitnis, Cygan, Hajiaghayi, and Marx proved
fixed-parameter tractability of the 2-terminal-pairs case at SODA 2012, and
Pilipczuk and Wahlstr\"{o}m proved the W[1]-hardness of the 4-terminal-pairs
case at SODA 2016.
On the technical side, we use two recent developments in parameterized
algorithms. Using the technique of directed flow-augmentation [Kim, Kratsch,
Pilipczuk, Wahlstr\"{o}m, STOC 2022] we cast the problem as a CSP problem with
few variables and constraints over a large ordered domain.We observe that this
problem can be in turn encoded as an FO model-checking task over a structure
consisting of a few 0-1 matrices. We look at this problem through the lenses of
twin-width, a recently introduced structural parameter [Bonnet, Kim,
Thomass\'{e}, Watrigant, FOCS 2020]: By a recent characterization [Bonnet,
Giocanti, Ossona de Mendes, Simon, Thomass\'{e}, Toru\'{n}czyk, STOC 2022] the
said FO model-checking task can be done in FPT time if the said matrices have
bounded grid rank. To complete the proof, we show an irrelevant vertex rule: If
any of the matrices in the said encoding has a large grid minor, a vertex
corresponding to the ``middle'' box in the grid minor can be proclaimed
irrelevant -- not contained in the sought solution -- and thus reduced.

We show that the $b$-Coloring problem is complete for the class XNLP when
parameterized by the pathwidth of the input graph. Besides determining the
precise parameterized complexity of this problem, this implies that b-Coloring
parameterized by pathwidth is $W[t]$-hard for all $t$, and resolves the
parameterized complexity of $b$-Coloring parameterized by treewidth.

One of the first application of the recently introduced technique of
\emph{flow-augmentation} [Kim et al., STOC 2022] is a fixed-parameter algorithm
for the weighted version of \textsc{Directed Feedback Vertex Set}, a landmark
problem in parameterized complexity. In this note we explore applicability of
flow-augmentation to other weighted graph separation problems parameterized by
the size of the cutset. We show the following. -- In weighted undirected graphs
\textsc{Multicut} is FPT, both in the edge- and vertex-deletion version. -- The
weighted version of \textsc{Group Feedback Vertex Set} is FPT, even with an
oracle access to group operations. -- The weighted version of \textsc{Directed
Subset Feedback Vertex Set} is FPT. Our study reveals \textsc{Directed
Symmetric Multicut} as the next important graph separation problem whose
parameterized complexity remains unknown, even in the unweighted setting.

Formal models of learning from teachers need to respect certain criteria to
avoid collusion. The most commonly accepted notion of collusion-freeness was
proposed by Goldman and Mathias (1996), and various teaching models obeying
their criterion have been studied. For each model $M$ and each concept class
$\mathcal{C}$, a parameter $M$-$\mathrm{TD}(\mathcal{C})$ refers to the
teaching dimension of concept class $\mathcal{C}$ in model $M$---defined to be
the number of examples required for teaching a concept, in the worst case over
all concepts in $\mathcal{C}$.
This paper introduces a new model of teaching, called no-clash teaching,
together with the corresponding parameter $\mathrm{NCTD}(\mathcal{C})$.
No-clash teaching is provably optimal in the strong sense that, given any
concept class $\mathcal{C}$ and any model $M$ obeying Goldman and Mathias's
collusion-freeness criterion, one obtains $\mathrm{NCTD}(\mathcal{C})\le
M$-$\mathrm{TD}(\mathcal{C})$. We also study a corresponding notion
$\mathrm{NCTD}^+$ for the case of learning from positive data only, establish
useful bounds on $\mathrm{NCTD}$ and $\mathrm{NCTD}^+$, and discuss relations
of these parameters to the VC-dimension and to sample compression.
In addition to formulating an optimal model of collusion-free teaching, our
main results are on the computational complexity of deciding whether
$\mathrm{NCTD}^+(\mathcal{C})=k$ (or $\mathrm{NCTD}(\mathcal{C})=k$) for given
$\mathcal{C}$ and $k$. We show some such decision problems to be equivalent to
the existence question for certain constrained matchings in bipartite graphs.
Our NP-hardness results for the latter are of independent interest in the study
of constrained graph matchings.

For a positive integer $\ell \geq 3$, the $C_\ell$-Contractibility problem
takes as input an undirected simple graph $G$ and determines whether $G$ can be
transformed into a graph isomorphic to $C_\ell$ (the induced cycle on $\ell$
vertices) using only edge contractions. Brouwer and Veldman [JGT 1987] showed
that $C_4$-Contractibility is NP-complete in general graphs. It is easy to
verify that $C_3$-Contractibility is polynomial-time solvable. Dabrowski and
Paulusma [IPL 2017] showed that $C_{\ell}$-Contractibility is \NP-complete\ on
bipartite graphs for $\ell = 6$ and posed as open problems the status of the
problem when $\ell$ is 4 or 5. In this paper, we show that both
$C_5$-Contractibility and $C_4$-Contractibility are NP-complete on bipartite
graphs.

We introduce the notion of {\em fair cuts} as an approach to leverage
approximate $(s,t)$-mincut (equivalently $(s,t)$-maxflow) algorithms in
undirected graphs to obtain near-linear time approximation algorithms for
several cut problems. Informally, for any $\alpha\geq 1$, an $\alpha$-fair
$(s,t)$-cut is an $(s,t)$-cut such that there exists an $(s,t)$-flow that uses
$1/\alpha$ fraction of the capacity of \emph{every} edge in the cut. (So, any
$\alpha$-fair cut is also an $\alpha$-approximate mincut, but not vice-versa.)
We give an algorithm for $(1+\epsilon)$-fair $(s,t)$-cut in
$\tilde{O}(m)$-time, thereby matching the best runtime for
$(1+\epsilon)$-approximate $(s,t)$-mincut [Peng, SODA '16]. We then demonstrate
the power of this approach by showing that this result almost immediately leads
to several applications:
- the first nearly-linear time $(1+\epsilon)$-approximation algorithm that
computes all-pairs maxflow values (by constructing an approximate Gomory-Hu
tree). Prior to our work, such a result was not known even for the special case
of Steiner mincut [Dinitz and Vainstein, STOC '94; Cole and Hariharan, STOC
'03];
- the first almost-linear-work subpolynomial-depth parallel algorithms for
computing $(1+\epsilon)$-approximations for all-pairs maxflow values (again via
an approximate Gomory-Hu tree) in unweighted graphs;
- the first near-linear time expander decomposition algorithm that works even
when the expansion parameter is polynomially small; this subsumes previous
incomparable algorithms [Nanongkai and Saranurak, FOCS '17; Wulff-Nilsen, FOCS
'17; Saranurak and Wang, SODA '19].