arXiv subjects

Joe Sawada

Publications and source records attributed to Joe Sawada.

At least 19 recordsLinked to original sources

arXiv2026

Shorthand Universal Tori for Permutations: Existence, Symmetry, and Generation of Twori

A de Bruijn sequence packs all $n$-bit binary words into a cycle of length $2^n$. A de Bruijn torus is the two-dimensional analogue in which each word appears exactly once in a rectangular window. Here we consider the natural analogue for permutations using their shorthand representation (i.e., each permutation's final redundant value is omitted from the window). We show that these tori exist when $n = 2m + 1$ is odd and the torus and windows have two rows (i.e., the torus is a "tworus"). These twori can be constructed with a high degree of symmetry. More specifically, there are twori that can be partitioned into $2^{m-1}$ matching blocks where each block contains the same sequence of unordered columns. Furthermore, given one such block we can generate each successive column of a tworus in amortized $\mathcal{O}(1)$-time. We also prove non-existence results for certain sizes of tori and provide algorithms for constructing multiversal cycles (perfect necklaces) of unlabeled binary words.

math.CO↗

arXiv2026

Construction of orientable sequences in $O(1)$-amortized time per bit

An orientable sequence of order $n$ is a cyclic binary sequence such that each length-$n$ substring appears at most once \emph{in either direction}. Maximal length orientable sequences are known only for $n\leq 7$, and a trivial upper bound on their length is $2^{n-1} - 2^{\lfloor(n-1)/2\rfloor}$. This paper presents the first efficient algorithm to construct orientable sequences that reach this upper bound, asymptotically; more specifically, our algorithm constructs orientable sequences via cycle-joining and a successor-rule approach requiring $O(n)$ time per bit and $O(n)$ space. This answers a longstanding open question from Dai, Martin, Robshaw, Wild [Cryptography and Coding III (1993)]. Applying a recent concatenation-tree framework, the same sequences can be generated in $O(1)$-amortized time per bit using $O(n^2)$ space. Our sequences are applied to find new longest-known (aperiodic) orientable sequences for $n\leq 20$.

cs.DS↗

arXiv2026

Necklaces and Lyndon words in colexicographic order

We present the first constant-amortized-time algorithms for generating all length-$n$ necklaces and Lyndon words over a $k$-letter alphabet in colexicographic order, for arbitrary $k\geq 2$. Our approach introduces a novel class of words called \emph{quasinecklaces}, which serve as an easily generated superset of necklaces through which all necklaces can be efficiently identified. We derive a formula for the number $Q_k(n)$ of length-$n$ quasinecklaces and show that $Q_k(n)$ is proportional to the number of length-$n$ necklaces, which is the key property needed to achieve constant amortized time. We also apply our results to efficiently generate a well-known de Bruijn sequence and efficiently generate necklaces and Lyndon words subject to a weight constraint.

math.CO↗

arXiv2026

Decoding universal cycles for t-subsets and t-multisets by decoding bounded-weight de Bruijn sequences

A universal cycle for a set S of combinatorial objects is a cyclic sequence of length |S| that contains a representative of each element in S exactly once as a substring. Despite the many universal cycle constructions known in the literature for various sets including k-ary strings of length n, permutations of order n, t-subsets of an n-set, and t-multisets of an n-set, remarkably few have efficient decoding (ranking/unranking) algorithms. In this paper we develop the first polynomial time/space decoding algorithms for bounded-weight de Bruijn sequences for strings of length nover an alphabet of size k. The results are then applied to decode universal cycles for t-subsets and t-multisets.

cs.DM↗

arXiv2026

Universal cycle constructions for k-subsets and k-multisets

A universal cycle for a set S of combinatorial objects is a cyclic sequence of length |S|that contains a representation of each element in S exactly once as a substring. If S is the set of k-subsets of [n] = {1, 2, . . . , n}, it is well-known that universal cycles do not always exists when applying a simple string representation, where 12 or 21 could represent the subset {1, 2}. Similarly, if S is the set of k-multisets of [n], it is also known that universal cycles do not always exist using a similar representation, where 112, 121, or 211 could represent the multiset {1, 1, 2}. By mapping these sets to an appropriate family of labeled graphs, universal cycles are known to exist, but without a known efficient construction. In this paper we consider a new representation for k-subsets and k-multisets that leads to efficient universal cycle constructions for all n, k >=2. We provide successor-rule algorithms to construct such universal cycles in O(n) time per symbol using O(n) space and demonstrate that necklace concatenation algorithms allow the same sequences to be generated in O(1) amortized time per symbol. They are the first known efficient universal cycle constructions for k-multisets. The results are obtained by considering constructions for bounded-weight de Bruijn sequences. In particular, we demonstrate that a bounded-weight generalization of the Grandmama de Bruijn sequence can be constructed in O(1) amortized time per symbol.

cs.DM↗

arXiv2025

Las Vegas algorithms to generate universal cycles and de Bruijn sequences uniformly at random

We present practical algorithms for generating universal cycles uniformly at random. In particular, we consider universal cycles for shorthand permutations, subsets and multiset permutations, weak orders, and orientable sequences. Additionally, we consider de Bruijn sequences, weight-range de Bruin sequences, and de Bruijn sequences, with forbidden $0^z$ substring. Each algorithm, seeded with a random element from the given set, applies a random walk of an underlying Eulerian de Bruijn graph to obtain a random arborescence (spanning in-tree). Given the random arborescence and the de Bruijn graph, a corresponding random universal cycle can be generated in constant time per symbol. We present experimental results on the average cover time needed to compute a random arborescence for each object using a Las Vegas algorithm.

cs.DM↗

arXiv2024

Constructing $k$-ary Orientable Sequences with Asymptotically Optimal Length

An orientable sequence of order $n$ over an alphabet $\{0,1,\ldots, k{-}1\}$ is a cyclic sequence such that each length-$n$ substring appears at most once \emph{in either direction}. When $k= 2$, efficient algorithms are known to construct binary orientable sequences, with asymptotically optimal length, by applying the classic cycle-joining technique. The key to the construction is the definition of a parent rule to construct a cycle-joining tree of asymmetric bracelets. Unfortunately, the parent rule does not generalize to larger alphabets. Furthermore, unlike the binary case, a cycle-joining tree does not immediately lead to a simple successor-rule when $k \geq 3$ unless the tree has certain properties. In this paper, we derive a parent rule to derive a cycle-joining tree of $k$-ary asymmetric bracelets. This leads to a successor rule that constructs asymptotically optimal $k$-ary orientable sequences in $O(n)$ time per symbol using $O(n)$ space. In the special case when $n=2$, we provide a simple construction of $k$-ary orientable sequences of maximal length.

cs.DM↗

arXiv2023

Cut-Down de Bruijn Sequences

A cut-down de Bruijn sequence is a cyclic string of length $L$, where $1 \leq L \leq k^n$, such that every substring of length $n$ appears at most once. Etzion [Theor. Comp. Sci 44 (1986)] gives an algorithm to construct binary cut-down de Bruijn sequences that requires $o(n)$ simple $n$-bit operations per symbol generated. In this paper, we simplify the algorithm and improve the running time to $\mathcal{O}(n)$ time per symbol generated using $\mathcal{O}(n)$ space. We then provide the first successor-rule approach for constructing a binary cut-down de Bruijn sequence by leveraging recent ranking algorithms for fixed-density Lyndon words. Finally, we develop an algorithm to generate cut-down de Bruijn sequences for $k>2$ that runs in $\mathcal{O}(n)$ time per symbol using $\mathcal{O}(n)$ space after some initialization. While our $k$-ary algorithm is based on our simplified version of Etzion's binary algorithm, a number of non-trivial adaptations are required to generalize to larger alphabets.

cs.DS↗

arXiv2023

Efficient constructions of the Prefer-same and Prefer-opposite de Bruijn sequences

The greedy Prefer-same de Bruijn sequence construction was first presented by Eldert et al.[AIEE Transactions 77 (1958)]. As a greedy algorithm, it has one major downside: it requires an exponential amount of space to store the length $2^n$ de Bruijn sequence. Though de Bruijn sequences have been heavily studied over the last 60 years, finding an efficient construction for the Prefer-same de Bruijn sequence has remained a tantalizing open problem. In this paper, we unveil the underlying structure of the Prefer-same de Bruijn sequence and solve the open problem by presenting an efficient algorithm to construct it using $O(n)$ time per bit and only $O(n)$ space. Following a similar approach, we also present an efficient algorithm to construct the Prefer-opposite de Bruijn sequence.

cs.DM↗

arXiv2022

Vertex-critical $(P_3+\ell P_1)$-free and vertex-critical (gem, co-gem)-free graphs

A graph $G$ is $k$-vertex-critical if $χ(G)=k$ but $χ(G-v)<k$ for all $v\in V(G)$ where $χ(G)$ denotes the chromatic number of $G$. We show that there are only finitely many $k$-critical $(P_3+\ell P_1)$-free graphs for all $k$ and all $\ell$. Together with previous results, the only graphs $H$ for which it is unknown if there are an infinite number of $k$-vertex-critical $H$-free graphs is $H=(P_4+\ell P_1)$ for all $\ell\ge 1$. We consider a restriction on the smallest open case, and show that there are only finitely many $k$-vertex-critical (gem, co-gem)-free graphs for all $k$, where gem$=\overline{P_4+P_1}$. To do this, we show the stronger result that every vertex-critical (gem, co-gem)-free graph is either complete or a clique expansion of $C_5$. This characterization allows us to give the complete list of all $k$-vertex-critical (gem, co-gem)-free graphs for all $k\le 16$

math.CO↗

arXiv2022

Pivot Gray Codes for the Spanning Trees of a Graph ft. the Fan

We consider the problem of listing all spanning trees of a graph $G$ such that successive trees differ by pivoting a single edge around a vertex. Such a listing is called a "pivot Gray code", and it has more stringent conditions than known "revolving-door" Gray codes for spanning trees. Most revolving-door algorithms employ a standard edge-deletion/edge-contraction recursive approach which we demonstrate presents natural challenges when requiring the "pivot" property. Our main result is the discovery of a greedy strategy to list the spanning trees of the fan graph in a pivot Gray code order. It is the first greedy algorithm for exhaustively generating spanning trees using such a minimal change operation. The resulting listing is then studied to find a recursive algorithm that produces the same listing in $O(1)$-amortized time using $O(n)$ space. Additionally, we present $O(n)$-time algorithms for ranking and unranking the spanning trees for our listing; an improvement over the generic $O(n^3)$-time algorithm for ranking and unranking spanning trees of an arbitrary graph. Finally, we discuss how our listing can be applied to find a pivot Gray code for the wheel graph.

cs.DS↗

arXiv2021

Gray codes and symmetric chains

We consider the problem of constructing a cyclic listing of all bitstrings of length $2n+1$ with Hamming weights in the interval $[n+1-\ell,n+\ell]$, where $1\leq \ell\leq n+1$, by flipping a single bit in each step. This is a far-ranging generalization of the well-known middle two levels problem (the case $\ell=1$). We provide a solution for the case $\ell=2$, and we solve a relaxed version of the problem for general values of $\ell$, by constructing cycle factors for those instances. The proof of the first result uses the lexical matchings introduced by Kierstead and Trotter, which we generalize to arbitrary consecutive levels of the hypercube. The proof of the second result uses symmetric chain decompositions of the hypercube, a concept known from the theory of posets. We also present several new constructions of such decompositions based on lexical matchings. In particular, we construct four pairwise edge-disjoint symmetric chain decompositions of the $n$-dimensional hypercube for any $n\geq 12$.

math.CO↗

arXiv2021

Investigating the discrepancy property of de Bruijn sequences

The discrepancy of a binary string refers to the maximum (absolute) difference between the number of ones and the number of zeroes over all possible substrings of the given binary string. We provide an investigation of the discrepancy of known simple constructions of de Bruijn sequences. Furthermore, we demonstrate constructions that attain the lower bound of $Θ(n)$ and a new construction that attains the previously known upper bound of $Θ(\frac{2^n}{\sqrt{n}})$. This extends the work of Cooper and Heitsch~[\emph{Discrete Mathematics}, 310 (2010)].

cs.DM↗

arXiv2021

A Pivot Gray Code Listing for the Spanning Trees of the Fan Graph

We use a greedy strategy to list the spanning trees of the fan graph, $F_n$, such that successive trees differ by pivoting a single edge around a vertex. It is the first greedy algorithm for exhaustively generating spanning trees using such a minimal change operation. The resulting listing is then studied to find a recursive algorithm that produces the same listing in $O(1)$-amortized time using $O(n)$ space. Additionally, we present $O(n)$-time algorithms for ranking and unranking the spanning trees for our listing; an improvement over the generic $O(n^3)$-time algorithm for ranking and unranking spanning trees of an arbitrary graph.

cs.DS↗

arXiv2021

Inside the Binary Reflected Gray Code: Flip-Swap Languages in 2-Gray Code Order

A flip-swap language is a set S of binary strings of length n such that $S \cup 0^n$ is closed under two operations (when applicable): (1) Flip the leftmost 1; and (2) Swap the leftmost 1 with the bit to its right. Flip-swap languages model many combinatorial objects including necklaces, Lyndon words, prefix normal words, left factors of k-ary Dyck words, and feasible solutions to 0-1 knapsack problems. We prove that any flip-swap language forms a cyclic 2-Gray code when listed in binary reflected Gray code (BRGC) order. Furthermore, a generic successor rule computes the next string when provided with a membership tester. The rule generates each string in the aforementioned flip-swap languages in O(n)-amortized per string, except for prefix normal words of length n which require O($n^{1.864}$)-amortized per string. Our work generalizes results on necklaces and Lyndon words by Vajnovski [Inf. Process. Lett. 106(3):96$-$99, 2008].

math.CO↗

arXiv2021

A Hamilton Cycle in the $k$-Sided Pancake Network

We present a Hamilton cycle in the $k$-sided pancake network and four combinatorial algorithms to traverse the cycle. The network's vertices are coloured permutations $π= p_1p_2\cdots p_n$, where each $p_i$ has an associated colour in $\{0,1,\ldots, k{-}1\}$. There is a directed edge $(π_1,π_2)$ if $π_2$ can be obtained from $π_1$ by a "flip" of length $j$, which reverses the first $j$ elements and increments their colour modulo $k$. Our particular cycle is created using a greedy min-flip strategy, and the average flip length of the edges we use is bounded by a constant.

math.CO↗

arXiv2020

Generating a Gray code for prefix normal words in amortized polylogarithmic time per word

A prefix normal word is a binary word with the property that no substring has more $1$s than the prefix of the same length. By proving that the set of prefix normal words is a bubble language, we can exhaustively list all prefix normal words of length $n$ as a combinatorial Gray code, where successive strings differ by at most two swaps or bit flips. This Gray code can be generated in $\Oh(\log^2 n)$ amortized time per word, while the best generation algorithm hitherto has $\Oh(n)$ running time per word. We also present a membership tester for prefix normal words, as well as a novel characterization of bubble languages.

cs.DS↗

arXiv2020

Dichotomizing $k$-vertex-critical $H$-free graphs for $H$ of order four

For $k \geq 3$, we prove (i) there is a finite number of $k$-vertex-critical $(P_2+\ell P_1)$-free graphs and (ii) $k$-vertex-critical $(P_3+P_1)$-free graphs have at most $2k-1$ vertices. Together with previous research, these results imply the following characterization where $H$ is a graph of order four: There is a finite number of $k$-vertex-critical $H$-free graphs for fixed $k \geq 5$ if and only if $H$ is one of $\overline{K_4}, P_4, P_2 + 2P_1$, or $P_3 + P_1$. Our results imply the existence of new polynomial-time certifying algorithms for deciding the $k$-colorability of $(P_2+\ell P_1)$-free graphs for fixed $k$.

math.CO↗