Bimonotone enumeration

TL;DR

This paper introduces an efficient, memory-conscious algorithm for enumerating solutions to bimonotone functions, significantly improving performance over naive methods and extending previous algorithms for semimonotone enumeration.

Contribution

It presents a novel, highly parallelizable algorithm for enumerating bimonotone function values with improved memory and time complexity over prior approaches.

Findings

Memory usage is reduced to O(√n log n)

Time complexity is O(n log^2 n) for enumerating n values

Algorithm is highly parallelizable and memory-efficient

Abstract

Solutions of a diophantine equation $f(a,b) = g(c,d)$, with $a,b,c,d$ in some finite range, can be efficiently enumerated by sorting the values of $f$ and $g$ in ascending order and searching for collisions. This article considers functions that are bimonotone in the sense that $f(a,b) \le f(a',b')$ whenever $a \le a'$ and $b \le b'$. A two-variable polynomial with non-negative coefficients is a typical example. The problem is to efficiently enumerate all pairs $(a,b)$ such that the values $f(a,b)$ appear in increasing order. We present an algorithm that is memory-efficient and highly parallelizable. In order to enumerate the first $n$ values of $f$, the algorithm only builds up a priority queue of length at most $\sqrt{2n}+1$. In terms of bit-complexity this ensures that the algorithm takes time $O(n \log^2 n)$ and requires memory $O(\sqrt{n} \log n)$, which considerably improves on the memory bound $\Theta(n \log n)$ provided by a naive approach, and extends the semimonotone enumeration algorithm previously considered by R.L. Ekl and D.J. Bernstein.