arXiv subjects

Keigo Oka

Publications and source records attributed to Keigo Oka.

6 recordsLinked to original sources

arXiv2026

Two-State Max-Plus Comparison Is Decidable

Daviaud, Guillon, and Merlet proved that comparison of max-plus automata is undecidable under a fixed state bound of 553 and explicitly left the range from 2 to 552 states open. We resolve the two-state endpoint. More strongly, given an arbitrary finite max-plus automaton $A$ and a max-plus automaton $B$ with at most two states, it is decidable whether $[\![A]\!](w)\leq [\![B]\!](w)$ for every word $w$. The structural reason is a one-dimensional projective normal form for two-state dynamics. Outside an effective bounded region, a transition has one of three tail behaviors: it propagates the unbounded projective gap with gap-independent height increment, forgets the gap with gap-independent height increment, or reads the gap magnitude into the height increment and then forgets it. In particular, any transition whose output depends on the unbounded gap necessarily destroys that gap. This yields an exact one-counter realization of $B$. Effective semilinearity of context-free Parikh images then reduces comparison to Presburger arithmetic. As a consequence, two-state max-plus comparison, equivalence, and positivity are decidable.

cs.FL↗

arXiv2026

Breaking the $2^n$ Barrier for Counting Linear Extensions with a Short Elementary Algorithm

A linear extension of a finite partially ordered set is a total ordering that respects the partial order. We give a deterministic exact algorithm that counts the linear extensions of an arbitrary $n$-element poset in time $O^*(1.89^n)$, where $O^*(\cdot)$ suppresses polynomial factors. This breaks the $2^n$ barrier for the general problem and resolves a question explicitly posed by Koivisto at Dagstuhl 2013. The proof refines an argument of Kozma for two-dimensional posets. A chain partition handles the case in which the poset is sufficiently far from an antichain. Otherwise, fix a maximum antichain (a largest set of pairwise incomparable elements). For each of its elements that has a comparable element above it outside the antichain, we record only which such element appears first. A decoding lemma enumerates the resulting patterns from their multiplicities. Once a pattern is fixed, each antichain element has a release condition and at most one deadline, so the dynamic program stores only the number of released elements in each deadline class. A stars-and-bars count bounds the total number of states.

cs.DS↗

arXiv2026

Turing Completeness of GNU find: From mkdir-assisted Loops to Standalone Computation

The Unix command \texttt{find} is among the first commands taught to beginners, yet remains indispensable for experienced engineers. In this paper, we demonstrate that \texttt{find} possesses unexpected computational power, establishing three Turing completeness results using the GNU implementation (a standard in Linux distributions). (1) \texttt{find} + \texttt{mkdir} (a system that has only \texttt{find} and \texttt{mkdir}) is Turing complete: by encoding computational states as directory paths and using regex back-references to copy substrings, we simulate 2-tag systems. (2) GNU \texttt{find} 4.9.0+ alone is Turing complete: by reading and writing to files during traversal, we simulate a two-counter machine without \texttt{mkdir}. (3) \texttt{find} + \texttt{mkdir} without regex back-references is still Turing complete: by a trick of encoding regex patterns directly into directory names, we achieve the same power. These results place \texttt{find} among the ``surprisingly Turing-complete'' systems, highlighting the hidden complexity within seemingly simple standard utilities.

cs.DS↗

arXiv2026

Covering a Polyomino-Shaped Stain with Non-Overlapping Identical Stickers

You find a stain on the wall and decide to cover it with non-overlapping stickers of a single identical shape (rotation and reflection are allowed). Is it possible to find a sticker shape that fails to cover the stain? In this paper, we consider this problem under polyomino constraints and complete the classification of always-coverable stain shapes (polyominoes). We provide proofs for the maximal always-coverable polyominoes and construct concrete counterexamples for the minimal not always-coverable ones, demonstrating that such cases exist even among hole-free polyominoes. This classification consequently yields an algorithm to determine the always-coverability of any given stain. We also show that the problem of determining whether a given sticker can cover a given stain is $\NP$-complete, even though exact cover is not demanded. This result extends to the 1D case where the connectivity requirement is removed. As an illustration of the problem complexity, for a specific hexomino (6-cell) stain, the smallest sticker found in our search that avoids covering it has, although not proven minimum, a bounding box of $325 \times 325$.

cs.DS↗

arXiv2014

Fast Dynamic Graph Algorithms for Parameterized Problems

Fully dynamic graph is a data structure that (1) supports edge insertions and deletions and (2) answers problem specific queries. The time complexity of (1) and (2) are referred to as the update time and the query time respectively. There are many researches on dynamic graphs whose update time and query time are $o(|G|)$, that is, sublinear in the graph size. However, almost all such researches are for problems in P. In this paper, we investigate dynamic graphs for NP-hard problems exploiting the notion of fixed parameter tractability (FPT). We give dynamic graphs for Vertex Cover and Cluster Vertex Deletion parameterized by the solution size $k$. These dynamic graphs achieve almost the best possible update time $O(\mathrm{poly}(k)\log n)$ and the query time $O(f(\mathrm{poly}(k),k))$, where $f(n,k)$ is the time complexity of any static graph algorithm for the problems. We obtain these results by dynamically maintaining an approximate solution which can be used to construct a small problem kernel. Exploiting the dynamic graph for Cluster Vertex Deletion, as a corollary, we obtain a quasilinear-time (polynomial) kernelization algorithm for Cluster Vertex Deletion. Until now, only quadratic time kernelization algorithms are known for this problem. We also give a dynamic graph for Chromatic Number parameterized by the solution size of Cluster Vertex Deletion, and a dynamic graph for bounded-degree Feedback Vertex Set parameterized by the solution size. Assuming the parameter is a constant, each dynamic graph can be updated in $O(\log n)$ time and can compute a solution in $O(1)$ time. These results are obtained by another approach.

cs.DS↗

arXiv2013

Linear-Time FPT Algorithms via Network Flow

In the area of parameterized complexity, to cope with NP-Hard problems, we introduce a parameter k besides the input size n, and we aim to design algorithms (called FPT algorithms) that run in O(f(k)n^d) time for some function f(k) and constant d. Though FPT algorithms have been successfully designed for many problems, typically they are not sufficiently fast because of huge f(k) and d. In this paper, we give FPT algorithms with small f(k) and d for many important problems including Odd Cycle Transversal and Almost 2-SAT. More specifically, we can choose f(k) as a single exponential (4^k) and d as one, that is, linear in the input size. To the best of our knowledge, our algorithms achieve linear time complexity for the first time for these problems. To obtain our algorithms for these problems, we consider a large class of integer programs, called BIP2. Then we show that, in linear time, we can reduce BIP2 to Vertex Cover Above LP preserving the parameter k, and we can compute an optimal LP solution for Vertex Cover Above LP using network flow. Then, we perform an exhaustive search by fixing half-integral values in the optimal LP solution for Vertex Cover Above LP. A bottleneck here is that we need to recompute an LP optimal solution after branching. To address this issue, we exploit network flow to update the optimal LP solution in linear time.

cs.DS↗