Log In Sign Up

A 2-Dimensional Binary Search for Integer Pareto Frontiers

by   Yotam gafni, et al.

For finite integer squares, we consider the problem of learning a classification I that respects Pareto domination. The setup is natural in dynamic programming settings. We show that a generalization of the binary search algorithm achieves an optimal θ(n) worst-case run time.


page 1

page 2

page 3

page 4


Do Outliers Ruin Collaboration?

We consider the problem of learning a binary classifier from n different...

A Quantum-Search-Aided Dynamic Programming Framework for Pareto Optimal Routing in Wireless Multihop Networks

Wireless Multihop Networks (WMHNs) have to strike a trade-off among dive...

Quantum-aided Multi-Objective Routing Optimization Using Back-Tracing-Aided Dynamic Programming

Pareto optimality is capable of striking the optimal trade-off amongst t...

Learning the Pareto Front with Hypernetworks

Multi-objective optimization problems are prevalent in machine learning....

Quantum Search with Prior Knowledge

Search-base algorithms have widespread applications in different scenari...

Exponential-Binary State-Space Search

Iterative deepening search is used in applications where the best cost b...

Learning Union of Integer Hypercubes with Queries (Technical Report)

We study the problem of learning a finite union of integer (axis-aligned...

1 Problem description and preliminaries

We consider a square finite integer grid parameterized by with

where . There is a classification function that respects Pareto domination [mas1995microeconomic]:

Definition 1.

Pareto domination We say a tuple Pareto-dominates a tuple if .

Pareto frontier Given a set with tuple elements of the form , we say is the Pareto frontier of if every element in is Pareto-dominated by an element of and no element of is Pareto-dominated by an element of .

Since respects Pareto domination, it is uniquely defined by a Pareto frontier of some set .

Lemma 1.

There is a 1-1 mapping between classification functions and Pareto frontiers in .


Every function has a 1-1 mapping to the set . The set has a 1-1 mapping to its Pareto frontier . Composing the two we get the result. ∎

We wish to learn the function . Our query model assumes that we can at each step choose some element of and observe . We show two simple upper bounds over learning :

Lemma 2.

Learning is


We query each element in , and . ∎

Lemma 3.

Learning is

For this lemma we consider the notion of a clash.

Definition 2.

For a row for some fixed , a clash is some integer value so that and .

Claim 1.

We can find a clash in


We implement a binary search over the query model: If we query some tuple and get , we go “up”, and if we get we go “down”. We stop when we get and we know returned (or ), or we get and know returned (or ). ∎

Claim 2.

Given a clash point for a row we know values for any .


Immediate from Pareto domination. ∎

We can now prove Lemma 3.


For every row , we find a clash point. We thus know values for all elements in the row. Since we do it for all rows, we know . The run time for each row is and over rows this is . ∎

2 Tight bounds

The above simple algorithms do not establish a tight upper bound for the problem.

Theorem 1.

Learning is .


We use the 1-1 mapping of Lemma 1. Since we learn at most bit of information with each query, of the number of Pareto frontiers for is a lower bound for any algorithm. We show an injection from permutations over values of and values of (overall values) into the Pareto frontiers of . For example, are all the permutations for .

Claim 3.

There is an injection from permutations over values of and values of (which is of size ) into the Pareto frontiers in .


Let be some permutation as described. We inject it into a series of clash points of length (one for each row of ). Let be a running index over the permutation, which we initialize with . Let , i.e., for any element in the first row value is . Let be the number of values in the permutation starting from . Let . Since there are values in , and each is immediately after the such value in the permutation, we have that , i.e., it marks the end of the permutation. Thus , as there are values in the permutation and all of them are covered by .

The series of clash points is weakly monotone decreasing and valid in the sense that each clash point is between and . It can be shown that every such series of clash points defines a unique Pareto frontier in . ∎

Using this injection, we are now able to prove the lower bound. Asymptotically, the central binomial coefficient [oeis] using Stirling’s approximation [feller1967direct]. Taking , we get , as required. ∎

We now present an asymptotically optimal algorithm that finds a series of clashes in , establishing a tight bound. As we know the series of clashes uniquely defines a Pareto frontier in , which defines a function .

Theorem 2.

There is an algorithm to find a Pareto frontier in .


Assume for simplicity that is an integer number.

Input: Recursion depth , Row number , lower border , upper border
Output: A series of all clashes in
1 Find a clash in row with borders . if  then
2       RecursiveClashFinder() RecursiveClashFinder()
Algorithm 1 RecursiveClashFinder

The algorithm runs over all rows, and thus finds all clashes and the Pareto frontier.

We examine the aggregate run time for all calls of the algorithm with the same depth . There are such calls. Notice that the calls are bounded to subsequent intervals that together cover . Each call finds a clash in the interval, and so is . By Jensen inequality [durrett2019probability], .

Summing over all possible depths, we get

We show by induction over that this sum is exactly , and thus establish an run time overall for the algorithm.

Claim 4.

For both sides are . Now,

which is exactly the expression we expect for (i.e., ). ∎

3 Discussion

The motivation of the problem is for dynamic programming. Say that there is some recursive rule over tuples that defines, given a current valid set , the next valid set . We also know that the recursive rule respects Pareto domination. In particular, the problem of finding an optimal deterministic -realizable online learning algorithm [shalev2014understanding] for label set

takes this form, but it should be pretty useful in dynamic programming and game theory in general.

An obvious generalization would be to -tuples, where much of the discussion extends naturally. The interesting question would be the run time of the algorithm. Since for we get the binary search in , and for we get the algorithm we presented in , it is not clear what should be the formula for general . We are however guaranteed an upper bound of by simply iterating over all possible values for the first coordinates and applying the two dimensional result.