In this paper, we discuss a new theorem of the alternative for integer feasibility in Unit Two Variable Per Inequality (UTVPI) constraints. Extensive research exists on theorems of the alternative for linear feasibility. Theorems of the alternative serve to provide a certificate of infeasibility. In the study of theorems of the alternative, there is a major focus on theorems of the alternative that provide “succinct” certificates. Such theorems of the alternative are called compact. In general, theorems of the alternative for linear feasibility are compact (see Farkas’ lemma, for instance). However, compact theorems of the alternative cannot exist for integer feasibility in general linear constraint systems unless NP=coNP. A second feature of a theorem of the alternative is its form. Typically, theorems of the alternative connect pairs of linear systems. On the other hand, a graphical theorem of the alternative relates the infeasibility of a linear system to the existence of specific structures in an appropriately constructed constraint network. Graphical theorems of the alternative are known to exist for selected classes of linear programs. In this paper, we provide a compact, graphical theorem of the alternative for integer feasibility in UTVPI constraints. In particular, our theorem of the alternative establishes this connection via an AC ^0 reduction. As noted in the paper, there exists a one to one correspondence between a UTVPI constraint system and the constraint network generated. This theorem of the alternative is then utilized to develop a new algorithm for checking the integer feasibility of a UTVPI constraint system (An extended abstract of this paper was presented at AI*IA 2019 [35]).
A border of a string is a non-empty proper prefix of the string that is also a suffix. A string is called unbordered if it has no border. The longest unbordered factor is a fundamental notion in stringology, closely related to string periodicity. This paper addresses the longest unbordered factor problem: given a string of length n, the goal is to compute its longest factor that is unbordered. While recent work has achieved subquadratic and near-linear time algorithms for this problem, the best known worst-case time complexity remains O(n log n) [Kociumaka et al., ISAAC 2018]. In this paper, we investigate the problem in the context of compressed string processing, focusing specifically on run-length encoded (RLE) strings. We first present a simple yet crucial structural observation relating unbordered factors and RLE-compressed strings. Building on this, we propose an algorithm that solves the problem in O(m^1.5log ^2 m) time and O(m log ^2 m) space, where m is the size of the RLE-compressed input string. Furthermore, we propose another algorithm for the problem that runs in average O(m log ^2 m) time and O(mlog m) space: The average-case bound holds under an exponent-bounded random-input model, in which the input is chosen uniformly from the strings of RLE size m whose run exponents are at most a given bound E≥ 2 . Our approaches extend key ideas from [Gawrychowski et al., SPIRE 2015] to the RLE setting through new combinatorial insights. When the RLE size m is sufficiently small compared to n, our algorithms achieve linear-time behavior in n, potentially leading to improved performance over existing methods in such cases.
In this article, we study d-reducibility and its injective counterpart, d_1 -reducibility. We prove a criterion for d-completeness in terms of fixed-point free functions and also show that a set is d-complete if and only if it is d_1 -complete. We also define a notion of (d,d_1) -cylinder, and, using this notion, prove that any noncomputable and nonsimple c.e. d-degree contains either only one or infinitely many d_1 -degrees.
A parameterized string (p-string) is a string that can contain two kinds of characters, static symbols and parameter characters. Parameterized pattern matching is a form of pattern matching that allows parameters to be renamed by applying a one-to-one function. The parameterized suffix array is a data structure that is useful in efficient parameterized pattern matching when accompanied by the parameterized longest common prefix (LCP) array. Reconstructing input from a given instance of a data structure is the task of determining whether the instance is valid or not, and if valid, producing a plausible set of data that it can represent. In this paper we consider parameterized suffix and LCP arrays and reconstruct a corresponding p-string that they can represent. In previous work, an algorithm can determine in O(n^2) time whether a p-string can be constructed to correspond to the input parameterized suffix and LCP arrays of size n [1]. In this work, we develop an algorithm that accomplishes this in Õ(n) time.
The Suffix Array is a classic text index enabling on-line pattern matching queries via simple binary search. The main drawback of the Suffix Array is that it takes linear space in the text’s length, even when the text itself is extremely compressible. Several works in the literature showed that the Suffix Array can be compressed, but they all rely on complex succinct data structures which in practice tend to exhibit poor cache locality and thus significantly slow down queries. In this paper, we propose a new simple and very efficient solution to this problem by presenting the Suffixient Array: a tiny subset of the Suffix Array sufficient to locate on-line one pattern occurrence (in general, all its Maximal Exact Matches) via binary search, provided that random access to the text is available. We prove that: (i) the Suffixient Array length χ is a strong repetitiveness measure, (ii) unlike most existing repetition-aware indexes such as the r -index, our new index is efficient in the I/O model, and (iii) Suffixient Arrays can be computed in linear time and compressed working space. We show experimentally that, when using well-established compressed random access data structures on repetitive collections, the Suffixient Array sA is simultaneously (i) faster and orders of magnitude smaller than the Suffix Array and (ii) smaller and one to two orders of magnitude faster than the r -index. With an average pattern matching query time as low as 3.5 ns per character, our new index gets very close to the ultimate lower bound: the RAM throughput of our workstation (1.18 ns per character).
