Suffix trees and suffix arrays are two fundamental data structures in the field of string algorithms. For a string (a.k.a. text or sequence) of length n over an alphabet of size sigma, these structures typically require O(n log n) bits of space. The FM-index provides a compressed representation of the suffix array in approximate to n log sigma bits, allowing for efficient queries on both the suffix array and its inverse array in near logarithmic time. In certain applications, such as approximate pattern matching (i.e., with wildcards, mismatches, edits), there is a need to access the suffix array of a text, as well as the suffix array of text's reverse. Motivated by this, we explore the possibility of encoding the suffix array of the reversed text in a compact form, assuming the availability of the FM-index for the original text. Our first solution is an O(n)-bit (relative) encoding of the suffix array of the reversed text, with the time for decoding an entry being only O(log* n) times that of decoding an entry in the text's suffix array using FM-index. We then demonstrate how to reduce the space to O(n/kappa) bits for a parameter kappa, while multiplicative factor in time becomes approximately O(kappa log* n + kappa(3)). We can also support inverse suffix array and longest common extension queries on the reversed text. These results are achieved through some careful and non-trivial application of various succinct data structure techniques.
We prove that, paying a polynomial increase in size only, every unrestricted two-way nondeterministic finite automaton (2NFA) can be complemented by a 1-limited automaton (1-LA), a nondeterministic extension of 2NFAS still characterizing regular languages. The resulting machine is actually a restricted form of 1-LAS - known as 2NFAS with common guess - and is self-verifying. A corollary of our construction is that a single exponential is necessary and sufficient for complementing 1-LAS.
We study the rent-or-buy variant of the online Steiner forest problem on node- and edge-weighted graphs. For n-node graphs with at most (n) over bar nodes of non-zero weight, and at most (k) over tilde different arriving terminal pairs, we obtain the following: - A deterministic, O(log n log (n) over bar)-competitive algorithm against adaptive adversaries. This improves on the previous best, O(log(4) n)-competitive algorithm obtained by the black-box reduction from [5] combined with the previously best deterministic algorithms for the simpler "buy-only" setting. - A deterministic, O((n) over bar log (k) over tilde)-competitive algorithm against adaptive adversaries. This generalizes the O(log (k) over tilde)-competitive algorithm for the purely edge-weighted setting from [24]. - A randomized, O(log (k) over tilde log (n) over bar)-competitive algorithm against oblivious adversaries. All previous approaches were based on the randomized, black-box reduction from [3] that achieves a O(log (k) over tildek log n)-competitive ratio when combined with an algorithm for the "buy-only" setting. Our key technical ingredient is a novel charging scheme to an instance of online prize-collecting set cover. This allows us to extend the witness-technique of [24] to the node-weighted setting and obtain refined guarantees with respect to (n) over bar, already in the much simpler "buy-only" setting.
With substantial progress in automated reasoning, algebraic approaches emerged to automatically analyse program loops in an exact manner. In this invited talk, we discuss recent results in characterizing the functional behaviour of loops with polynomial arithmetic and probabilistic updates. This problem remains unsolved even when we restrict consideration to loops that are non-nested, without conditionals, and/or without exit conditions [5, 11]. We are motivated by applications of computer-aided verification, in particular to assess the safety, security, and sensitivity of computer systems [8, 3, 2, 9, 1, 6]. We are interested in modeling, deciding, and solving loop analysis. The key to our work are moment-computable loops [7, 10] which allow us to set limits on what is decidable and solvable in loop analysis. Our approach combines algebra, statistics, and automated reasoning to mechanize loop analysis. Various techniques, such as martingale theory and quantifier elimination, can be seen as examples of moment-computable loop analysis. This talk is structured within three inter-connected parts. We first bring moment-based loop analysis into the landscape of loop invariant synthesis and extend moment-computable loops with termination guarantees. We next automate the reasoning about (probabilistic) loops by summarizing loop semantics as (probabilistic) algebraic recurrences, whose closed-form solutions capture (higher-order) moments, and hence invariants, among loop variables. These recurrences together with loop tests yield moment-based (super)martingales necessary to prove loop termination and compute probability bounds on termination. We finally describe moment-computable loops whose invariant synthesis decidable or as hard as open problems, such as the Skolem problem [4, 12].
We study the problem of broadcasting multiple messages in the CONGEST model. In this problem, a dedicated source node s possesses a set M of messages with every message of size O(log n) where n is the total number of nodes. The objective is to ensure that every node in the network learns all messages in M. The execution of an algorithm progresses in rounds, and we focus on optimizing the round complexity of broadcasting multiple messages. Our primary contribution is a randomized algorithm for networks with expander topology. The algorithm succeeds with high probability and achieves a round complexity that is optimal up to a factor of the network's mixing time and polylogarithmic terms. It leverages a multi-COBRA primitive, which uses multiple branching random walks running in parallel. A crucial aspect of our method is the use of these branching random walks to construct an optimal (up to a polylogarithmic factor) tree packing of a random graph, which is then used for efficient broadcasting. We also prove the problem to be NP-hard in a centralized setting and provide insights into why lower bounds that can be matched in expanders, namely graph diameter and vertical bar M vertical bar/minCut, cannot be tight in general graphs.
Twin-width is a graph parameter that has become central to explaining the fixed-parameter tractability of first-order model checking across many graph classes. Despite its algorithmic importance, computing twin-width remains poorly understood: even recognizing graphs of twin-width at most four is NP-hard, and no fixed-parameter approximations parameterized by twin-width itself are known. A recent approach towards breaking this barrier focuses on first developing fixed-parameter algorithms for computing or approximating twin-width under parameterizations distinct from twin-width. Our first result establishes that approximating twin-width is fixed-parameter tractable when parameterized by treedepth, thereby breaking the long-standing barrier that all previous tractable parameterizations were based on deletion distance. The proof proceeds via oriented twin-width, yielding the first constructive evidence that this variant may be easier to handle algorithmically. As our second main result, we show that computing twin-width exactly is fixed-parameter tractable with respect to vertex integrity. This constitutes the first non-trivial parameterized algorithm for computing optimal contraction sequences.
Given Boolean functions f, g : F-2(n) -> {-1, +1}, we say they are linearly isomorphic if there exists A is an element of GL(n)(F-2) such that f(x) = g(Ax) for all x. We study this problem in the tolerant property testing framework under the known-unknown model, where g is given explicitly and f is accessible only via oracle queries, meaning the algorithm may adaptively request the value of f(x) for inputs x is an element of F-2(n) of its choice. Given parameters epsilon >= 0 and omega > 0, the goal is to distinguish whether there exists A is an element of GL(n)(F-2) such that the normalized Hamming distance between f and g(Ax) is at most epsilon, or whether for every A is an element of GL(n)(F-2) the distance is at least epsilon+omega. Our main result is a tolerant tester making (O) over tilde (m/omega)(4)) queries to f, where m is an upper bound on the spectral norm of g, improving the previous (O) over tilde (m/omega)(24)) bound of Wimmer and Yoshida. We complement this with a nearly matching lower bound of Omega(m(2)) for constant. (for example, omega = 1/4), improving the prior Omega(log m) lower bound of Grigorescu, Wimmer and Xie. A key technical ingredient on the algorithmic side is a query-efficient local list corrector. For the lower bound, we give a reduction from communication complexity using a novel subclass of Maiorana-McFarland functions from symmetric-key cryptography.
We study truthful and non-truthful protocols for combinatorial auctions in which every item can be allocated to one of two agents (multigraphs), or more generally to a fixed number of agents (hypergraphs). We show some tight - both positive and impossibility - results for the communication complexity of approximating the optimal social welfare for general monotone, subadditive, or XOS valuations.
Hmelevskii proved in 1971 that every constant-free three-variable word equation has a parametric solution. We prove an improved version of this result by showing that every such equation has a parametric solution using only three numerical parameters and with only two levels of nesting. This means that the structure of the solution sets of these equations is considerably simpler than has been known before.
We consider the Unit Interval Selection problem in the one-pass random order streaming model. In this setting, an algorithm is presented with a sequence of n unit-length intervals on the line that arrive in uniform random order, one at a time, and the objective is to output (an approximation of) a largest set of disjoint intervals using space linear in the size of an optimal solution. Previous work only considered adversarially ordered streams and established that, within these space constraints, a (2/3)-approximation can be achieved in such streams, and this is best possible, in that going beyond such an approximation factor requires space Omega(n) [Emek et al., TALG'16]. In this work, we show that an improved expected approximation factor can be achieved if the input stream is in uniform random order, where the expectation is taken over the stream order. More specifically, we give a one-pass streaming algorithm with expected approximation factor 0.7401 that uses space O(|OPT|), where OPT denotes an optimal solution. We also show that random order algorithms with expected approximation factor above 8/9 require space Omega(n), and algorithms that compute a better than 2/3-approximation with probability above 2/3 also require Omega(n) space. On a technical level, we design an algorithm for the restricted domain [0,Delta), for some constant Delta, and use standard techniques to obtain an algorithm for unrestricted domains. For the restricted domain [0, Delta), we run O(Delta) recursive instances of our algorithm, with each instance targeting the situation where a specific interval of an optimal solution arrives first. We establish the interesting property of our algorithm that it performs worst when the input stream consists solely of a set of independent intervals. It then remains to analyse the algorithm on these simple instances. Our lower bound is proved via communication complexity arguments, similar in spirit to the robust communication lower bounds established by [Chakrabarti et al., Theory Comput. 2016].
Modern financial networks are highly connected and result in complex interdependencies of the involved institutions. In the prominent Eisenberg-Noe model [12], a fundamental aspect is clearing - to determine the amount of assets available to each financial institution in the presence of potential defaults and bankruptcy. A clearing state represents a fixed point that satisfies a set of natural axioms. Existence can be established (even in broad generalizations of the model) using Tarski's theorem. While a maximal fixed point can be computed in polynomial time, the complexity of computing other fixed points is open. In this paper, we provide an efficient algorithm to compute a minimal fixed point. Our algorithm applies in a broad generalization of the Eisenberg-Noe model with any monotone, piecewise-linear payment functions and default costs. We also study claims trading, a local network adjustment to improve clearing, when networks are evaluated with minimal clearing. We provide an efficient algorithm to decide existence of Pareto-improving trades and compute optimal ones if they exist.
We revisit the algorithmic problem of reconstructing a graph from homomorphism counts that has first been studied in (Boker et al., STACS 2024): given graphs F-1,..., F-k and counts m(1),..., m(k), decide if there is a graph G such that the number of homomorphisms from F-i to G is m(i), for all i. We prove that the problem is NEXP-hard if the counts mi are specified in binary and Sigma(p)(2)-complete if they are in unary. Furthermore, as a positive result, we show that the unary version can be solved in polynomial time if the constraint graphs are stars of bounded size.
A powerful design principle behind many modern string algorithms is local consistency: breaking the symmetry between string positions based on their small contexts so that matching fragments are handled consistently. Among the most influential instantiations of this principle are string synchronizing sets [Kempa & Kociumaka; STOC 2019]. A tau-synchronizing set of a string of length n is a set of O(n/tau) string positions, chosen using their length-2 tau contexts, such that (outside of highly periodic regions) every block of tau consecutive positions contains at least one element of the set. Synchronizing sets have found dozens of applications in diverse settings, from quantum and dynamic algorithms to fully compressed computation. In the classic word RAM model, particularly for strings over small alphabets, they enabled faster solutions to core problems in data compression, text indexing, and string similarity. In this work, we show that any string T is an element of[0.. sigma)(n) can be preprocessed in O(n log sigma/ log n) time so that, for any given integer t is an element of[1.. n], a tau-synchronizing set of T can be constructed in O(( n log tau)/(tau log n)) time. Both bounds are optimal in the word RAM model with machine word size w = Theta(log n), matching the information-theoretic minimum for the input and output sizes, respectively. Previously, constructing a tau-synchronizing set required O(n/tau) time after an O(n)-time preprocessing [Kociumaka, Radoszewski, Rytter, and Walen; SICOMP 2024], or, in the restricted regime of tau < 0.2 log(sigma)n, without any preprocessing needed [Kempa & Kociumaka; STOC 2019]. A simple instantiation of our method outputs the synchronizing set as a sorted list in O(n/tau) time, or as a bitmask in O(n/ log n) time. Our optimal construction produces a compact fully indexable dictionary, supporting select queries in O(1) time and rank queries in (O log(log tau/log log n)) time. The latter complexity matches known unconditional cell-probe lower bounds for tau = n(1-Omega(1)). To achieve this, we introduce a general framework for efficiently processing sparse integer sequences via a custom variable-length encoding. We also augment the optimal variant of van Emde Boas trees [Patrascu & Thorup; STOC 2006] with a deterministic linear-time construction. When the set is represented as a bitmask under our sparse encoding, the same guarantees for select and rank queries hold after preprocessing in time proportional to the size of our encoding (in words).
We study the reconfiguration of odd matchings of combinatorial graphs. Odd matchings are matchings that cover all but one vertex of a graph. A reconfiguration step, or flip, is an operation that matches the isolated vertex and, consequently, isolates another vertex. The flip graph of odd matchings is a graph that has all odd matchings of a graph as vertices and an edge between two vertices if their corresponding matchings can be transformed into one another via a single flip. We show that computing the diameter of the flip graph of odd matchings is Pi(p)(2)-hard. This complements a recent result by Wulf [FOCS25] that it is Pi(p)(2)-hard to compute the diameter of the flip graph of perfect matchings where a flip swaps matching edges along a single cycle of unbounded size. Further, we show that computing the radius of the flip graph of odd matchings is Sigma(p)(3)-hard. The respective decision problems for the diameter and the radius are also complete in the respective level of the polynomial hierarchy. This shows that computing the radius of the flip graph of odd matchings is provably harder than computing its diameter, unless the polynomial hierarchy collapses. Finally, we reduce set cover to the problem of finding shortest flip sequences. As a consequence, we show APX-hardness and that the problem cannot be approximated by a sublogarithmic factor. By doing so, we answer a question asked by Aichholzer, Brenner, Dorfer, Hoang, Perz, Rieck, and Verciani [GD25].
The Cartesian tree of a sequence captures the relative order of the sequence's elements. In recent years, Cartesian tree matching has attracted considerable attention, particularly due to its applications in time series analysis. Consider a text T of length n and a pattern P of length m. In the exact Cartesian tree matching problem, the task is to find all length-m fragments of T whose Cartesian tree coincides with the Cartesian tree CT(P) of the pattern. Although the exact version of the problem can be solved in linear time [Park et al., TCS 2020], it remains rather restrictive; for example, it is not robust to outliers in the pattern. To overcome this limitation, we consider the approximate setting, where the goal is to identify all fragments of T that are close to some string whose Cartesian tree matches CT(P). In this work, we quantify closeness via the widely used Hamming distance metric. For a given integer parameter k > 0, we present an algorithm that computes all fragments of T that are at Hamming distance at most k from a string whose Cartesian tree matches CT(P). Our algorithm runs in time O(n root m center dot k(2.5)) for k <= m(1/5) and in time O(nk(5)) for k <= m(1/5), thereby improving upon the state-of-the-art O(nmk)-time algorithm of Kim and Han [TCS 2025] in the regime k = o(m(1/4)). On the way to our solution, we develop a toolbox of independent interest. First, we introduce a new notion of periodicity in Cartesian trees. Then, we lift multiple well-known combinatorial and algorithmic results for string matching and periodicity in strings to Cartesian tree matching and periodicity in Cartesian trees.
Given a set of n circular arcs of the same radius in the plane, we consider the problem of computing the number of intersections among the arcs. The problem was studied before and the previously best algorithm solves the problem in O(n(4/3+epsilon)) time [Agarwal, Pellegrini, and Sharir, SIAM J. Comput., 1993], for any constant epsilon > 0. No progress has been made on the problem for more than 30 years. We present a new algorithm of O(n(4/3) log(16/3) n) time and improve it to O(n(1+epsilon) + K(1/3)n(2/3)(n(2)/n+K)(epsilon) log(16/3) n) time for small K, where K is the number of intersections of all arcs.
This paper explores the fine-grained structure of classes of regular languages maintainable in fragments of first-order logic within the dynamic descriptive complexity framework of Patnaik and Immerman. A result by Hesse states that the class of regular languages is maintainable by first-order formulas even if only unary auxiliary relations can be used. Another result by Gelade, Marquardt, and Schwentick states that the class of regular languages coincides with the class of languages maintainable by quantifier-free formulas with binary auxiliary relations. We refine Hesse's result and show that with unary auxiliary data there exists*for all*-formulas can maintain all regular languages. We then obtain precise algebraic characterizations of the classes of languages maintainable with quantifier-free formulas and positive there exists*-formulas in the presence of unary auxiliary relations.
We study the fully dynamic pattern matching problem where the pattern may contain up to k wildcard symbols, each matching any symbol of the alphabet. Both the text and the pattern are subject to updates (insert, delete, change). We design an algorithm with O(n log(2) n) preprocessing and update/query time (O) over tilde (kn(k/k+1) + k(2) log n). The bound is truly sublinear for a constant k, and sublinear when k = o(log n). We further complement our results with a conditional lower bound: assuming subquadratic preprocessing time, achieving truly sublinear update time for the case k = Omega(log n) would contradict the Strong Exponential Time Hypothesis (SETH). Finally, we develop sublinear algorithms for two special cases: If the pattern contains w non-wildcard symbols, we give an algorithm with preprocessing time O(nw) and update time O(w + log n), which is truly sublinear whenever w is truly sublinear. Using FFT technique combined with block decomposition, we design a deterministic truly sublinear algorithm with preprocessing time O(n(1.8)) and update time O(n(0.8) log n) for the case that there are at most two non-wildcards.
