Abstract 1 Introduction 2 Preliminaries 3 Algorithm for Orthogonal Vectors (𝟐-OV) 4 Algorithm for π’Œ-Orthogonal Vectors (π’Œ-OV) 5 Faster π’Œ-Orthogonal Vectors under the Asymptotic Rank Conjecture References

Faster Algorithms for k-Orthogonal Vectors in Low Dimension

Anita DΓΌrr ORCID ETH ZΓΌrich, Switzerland    Evangelos Kipouridis ORCID Max Planck Institute for Informatics, SaarbrΓΌcken, Germany    Michael Lampis ORCID UniversitΓ© Paris Dauphine, Paris, France    Karol WΔ™grzycki ORCID Max Planck Institute for Informatics, SaarbrΓΌcken, Germany
Abstract

In the Orthogonal Vectors problem (OV), we are given two families A,B of subsets of {1,…,d}, each of size n, and the task is to decide whether there exists a pair a∈A and b∈B such that a∩b=βˆ…. Straightforward algorithms for this problem run in π’ͺ⁒(n2β‹…d) or π’ͺ⁒(2dβ‹…n) time, and assuming SETH, there is no 2o⁒(d)β‹…n2βˆ’Ξ΅ time algorithm that solves this problem for any constant Ξ΅>0.

Williams (FOCS 2024) presented a π’ͺ~⁒(1.35dβ‹…n)-time algorithm for the problem, based on the succinct equality-rank decomposition of the disjointness matrix. In this paper, we present a combinatorial algorithm that runs in randomized time π’ͺ~⁒(1.25dβ‹…n). This can be improved to π’ͺ⁒(1.16dβ‹…n) using computer-aided evaluations.

We also consider a more general k-Orthogonal Vectors problem, where given k families A1,…,Ak of subsets of {1,…,d}, each of size n, the task is to find elements ai∈Ai for every i∈{1,…,k} such that a1∩a2βˆ©β€¦βˆ©ak=βˆ…. We show that for every fixed kβ©Ύ2, there exists Ξ΅k>0 such that the k-OV problem can be solved in time π’ͺ⁒(2(1βˆ’Ξ΅k)β‹…dβ‹…n). We also show that, asymptotically, this is the best we can hope for: for any Ξ΅>0 there exists a kβ©Ύ2 such that 2(1βˆ’Ξ΅)β‹…dβ‹…nπ’ͺ⁒(1) time algorithm for k-Orthogonal Vectors would contradict the Set Cover Conjecture.

Keywords and phrases:
Orthogonal Vectors, Fine-grained Complexity, Exact Algorithms, Set Cover
Category:
Track A: Algorithms, Complexity and Games
Funding:
Anita DΓΌrr: Part of this work was done while affiliated to Saarland University and Max Planck Institute for Informatics, SaarbrΓΌcken, Germany, where this work was part of the project TIPEA that has received funding from the European Research Council (ERC) under the European Unions Horizon 2020 research and innovation programme (grant agreement No. 850979).
Karol WΔ™grzycki: Supported by the Deutsche Forschungsgemeinschaft (DFG, German Research Foundation) grant number 559177164.
Copyright and License:
[Uncaptioned image] © Anita DΓΌrr, Evangelos Kipouridis, Michael Lampis, and Karol WΔ™grzycki; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation β†’ Design and analysis of algorithms
; Theory of computation β†’ Computational complexity and cryptography
Related Version:
Extended Version: https://arxiv.org/abs/2507.11098
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

In the Orthogonal Vectors problem, the task is to find a disjoint pair of vectors in a given collection of vectors. We view vectors in {0,1}d as subsets of {1,2,…,d} for some dimension d.

Definition 1.1 (Orthogonal Vectors (2-OV)).

Given two families A,B of subsets of {1,…,d} with |A|=|B|=n, the Orthogonal Vectors problem asks whether there exist a∈A and b∈B such that a∩b=βˆ….

The naive algorithm for the Orthogonal Vectors problem runs in π’ͺ⁒(n2β‹…d) time. This quadratic-time algorithm has been slightly improved to n2βˆ’1/π’ͺ⁒(log⁑(d/log⁑n))[6, 1], but no π’ͺ⁒(n2βˆ’Ξ΅)-time algorithm is currently known for any Ξ΅>0. In fact, the conjecture that there is no such Ξ΅>0 for which Orthogonal Vectors can be solved in π’ͺ⁒(n2βˆ’Ξ΅) time for d=ω⁒(log⁑n) is one of the central hypotheses in the field of fine-grained complexity [19]. The Orthogonal Vectors problem and its connections to other problems have been thoroughly investigated [7, 12], and a 2o⁒(d)β‹…n2βˆ’Ξ΅-time algorithm for any Ξ΅>0 would contradict the Strong Exponential Time Hypothesis [17].

In this paper we focus on the low-dimensional regime when d=c⁒log⁑n for some small constant c>0. In that regime, the SETH lower bound does not preclude the possibility of subquadratic algorithms. In fact, folklore algorithms with running times π’ͺ⁒(dβ‹…2dβ‹…n) or even π’ͺ~⁒(n+2d) are known [4]111π’ͺ~⁒(β‹…) hides polylogarithmic factors, while π’ͺ⋆⁒(β‹…) hides polynomial factors in the input. Since d=c⁒log⁑n for some constant c>0 throughout this paper, π’ͺ~ also hides polynomial factors in d..

Inspired by connections to non-uniform circuit lower bounds, Williams [18] investigated whether the dependence on d can be improved, and designed an π’ͺ~⁒(1.35dβ‹…n)-time algorithm for Orthogonal Vectors. Williams [18] exploited the structure of the problem by presenting a systematic approach based on constant-sized decompositions of the disjointness matrix.

Our first contribution is a new combinatorial algorithm for the problem:

Theorem 1.1.

The Orthogonal Vectors problem can be solved in π’ͺ~⁒(1.25dβ‹…n) time by a randomized, one-sided error algorithm that succeeds with probability 1βˆ’2βˆ’dΩ⁒(1). Using computer-aided evaluation, the running time can be improved to π’ͺ⁒(1.16dβ‹…n).

This result was independently discovered by Alman and Li [2]. It is worth noting that the technique of Williams [18] also allows one to deterministically count the number of solutions to the Orthogonal Vectors problem in π’ͺ~⁒(1.38dβ‹…n) time, whereas ours cannot count and is inherently randomized. Our approach is based on an application of the representation method [11]. In a nutshell, we observe that if a∩b=βˆ…, then there exists a certificate set c such that: (i) aβŠ†c, and (ii) b∩c=βˆ…. Our algorithm samples an appropriate number of such sets and constructs a data structure that certifies conditions (i) and (ii).

We remark that, using computer-aided evaluation, the running time of our algorithm can be improved to π’ͺ⁒(1.16dβ‹…n). This constant is very close to the barrier achievable with current techniques when the size of a and b is d/4: in that setting, a similar approach was used to design a π’ͺ⁒(1.14dβ‹…n) time algorithm for Orthogonal Vectors. Any improvement on that running time would improve known algorithms for Subset Sum [13].

Next, we consider a more general k-Orthogonal Vectors problem:

Definition 1.2 (k-Orthogonal Vectors (k-OV)).

Given families A1,…,Ak of subsets of {1,…,d}, each of size n, the k-Orthogonal Vectors problem asks whether there exist a1∈A1,…,ak∈Ak such that a1∩a2βˆ©β€¦βˆ©ak=βˆ….

Naive algorithms for the k-Orthogonal Vectors problem run in π’ͺ⁒(dβ‹…kβ‹…nk) time, and any 2o⁒(d)β‹…nkβˆ’Ξ΅ time algorithm for Ξ΅>0 would contradict SETH. As in the 2-OV case, for every fixed kβ©Ύ2, a folklore algorithm solves the k-Orthogonal Vectors problem in π’ͺ⁒(dβ‹…2dβ‹…n) time. We show that the exponential dependence on d can be improved:

Theorem 1.2.

For every kβ©Ύ2, there exists Ξ΅k>0 such that the k-Orthogonal Vectors problem can be solved deterministically in time π’ͺ⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n).

To prove the theorem, we observe that the algorithm of BjΓΆrklund et al. [4] can be generalized to give a π’ͺ(dβ‹…(|↓A1|+…+|↓Ak|))-time algorithm for the k-Orthogonal Vectors problem, where ↓F≔{xβŠ†s∣s∈F} denotes the down-closure of the family F. First, guess the cardinalities of the solution 1β©½Ξ±1⁒d⩽…⩽αk⁒dβ©½d and assume that the family Ai contains only sets of cardinality Ξ±i⁒d. If Ξ±k<(1βˆ’Ξ΅) for some Ξ΅>0, then |↓Ai|β©½2(1βˆ’Ξ΅)⁒d|Ai| for each i∈{1,…,k} and thus the above algorithm runs in time π’ͺ⁒(2(1βˆ’Ξ΅)⁒dβ‹…n). Therefore, consider the case where Ξ±k>(1βˆ’Ξ΅). Then |Ak|β©½(dΡ⁒d). Hence, we can afford to guess a set ak∈Ak and recurse on the (kβˆ’1)-Orthogonal Vectors problem with universe ak. We continue this process until we reach the case k=2, at which point we can use a deterministic algorithm for k=2.

Finally, we observe that ˜1.2 is asymptotically optimal: having a 2(1βˆ’Ξ΅)⁒dβ‹…nπ’ͺ⁒(1)-time algorithm that solves k-Orthogonal Vectors for every kβ©Ύ2 would drastically improve the currently best algorithms for Set Cover.

Theorem 1.3.

For every c>0 and Ξ΅>0, there exists kβˆˆβ„• such that the k-Orthogonal Vectors problem is not solvable in π’ͺ⁒(2(1βˆ’Ξ΅)⁒dβ‹…nc) time, assuming the Set Cover Conjecture.

Recently, it has been shown that the Set Cover Conjecture and the Asymptotic Rank Conjecture cannot both be true [5, 14]. We show that these techniques can also be used to conditionally improve algorithms for k-Orthogonal Vectors:

Theorem 1.4.

Assuming the Asymptotic Rank Conjecture, there exist c>0 and Ξ΅>0, such that any k-Orthogonal Vectors instance can be solved in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…dβ‹…nc) time for every kβˆˆβ„•.

As these results are relatively straightforward corollaries of the known connections, we include them in Section 5.

Related Work.

As mentioned before, techniques used in this paper are inspired by [13] which in turn is based on the more general framework of Fomin et al. [11]. These techniques have also been used to give a faster algorithm for Subset Balancing Problems [15]. Similar techniques have also been used by Chukhin et al. [8] in the context of monotone circuits and matrix rigidity.

Organization.

After introducing notations and discussing a folklore algorithm in Section 2, we give our algorithm for the Orthogonal Vectors problem in Section 3. In Section 4 we give our algorithm for the k-Orthogonal Vectors problem. Equivalence between k-Orthogonal Vectors and Set Cover is provided in Section 5.

2 Preliminaries

We use the shorthand notation [n]≔{1,2,…,n} for any nβˆˆβ„•. For a universe set u and a set family FβŠ†2u, we denote the down-closure of F as ↓F≔{xβŠ†s∣s∈F}. We use sβŠ†RF to denote that s is a subset of F chosen uniformly at random among all such subsets. For a non-negative integer iβ©½|u|, the set of subsets of u of size i is denoted (ui). We use xβŠ”y to denote a disjoint partition. We use the Iverson bracket notation for the characteristic function; i.e. for any logical expression b, the value of ⟦b⟧ is 1 if b is true and 0 otherwise.

Binomial Coefficients.

The binary entropy function is defined as h⁒(Ξ±)β‰”βˆ’Ξ±β’log2⁑(Ξ±)βˆ’(1βˆ’Ξ±)⁒log2⁑(1βˆ’Ξ±) for every α∈(0,1), and h⁒(Ξ±)=0 for α∈{0,1}. We use it to approximate binomial coefficients with the following inequalities [16]:

2h⁒(Ξ±)⁒nβ©Ύ(nα⁒n)⩾Ω⁒(2h⁒(Ξ±)⁒nβ‹…nβˆ’1/2), (1)

for every α∈(0,1). The binary entropy function generalizes to the multinomial form. For Ξ±1,…,Ξ±k∈(0,1) with βˆ‘i=1kΞ±i=1 it is defined as:

h⁒(Ξ±1,…,Ξ±k)β‰”βˆ’βˆ‘i=1kΞ±i⁒log2⁑αi.

Note that for α∈(0,1), we use the shorthand notation h⁒(Ξ±)≔h⁒(Ξ±,1βˆ’Ξ±). The multinomial coefficient can be approximated with the function h as follows:

Lemma 2.1 ([9], Lemma 2.2).
2h⁒(Ξ±1,…,Ξ±k)⁒nβ‹…nβˆ’π’ͺ⁒(k)β©½(nΞ±1⁒n,…,Ξ±k⁒n)β©½2h⁒(Ξ±1,…⁒αk)⁒n.

Orthogonal Vectors.

Throughout the paper, we denote by n the number of vectors given in each family of an OV instance and by d the dimension of the vectors. Vectors in {0,1}d are often interpreted as subsets of [d], and we use these terms interchangeably. We always assume that d=c⁒log⁑n for some constant c>0. For completeness, we include a simple deterministic algorithm for 2-OV. Notice that [18] offers a faster deterministic algorithm. However, the running time proven below is enough for the base case of the recursive algorithm in ˜1.2.

Lemma 2.2.

The Orthogonal Vectors problem can be solved deterministically in π’ͺ~⁒(2d/2β‹…n) time.

Proof.

Partition the universe [d] into the low order bits uL={1,…,⌊d/2βŒ‹} and high order bits uH={⌊d/2βŒ‹+1,…,d}. For any subset xβŠ†[d], we write x=xL⊎xH for xL=x∩uL and xH=x∩uH. Consider the following sets of vectors:

SA≔ {aL⊎xHβŠ†[d]∣aL⊎aH∈A,xHβŠ†uH,xH∩aH=βˆ…},
SB≔ {xL⊎bHβŠ†[d]∣bL⊎bH∈B,xLβŠ†uL,xL∩bL=βˆ…}.

We claim that SA∩SBβ‰ βˆ… if and only if an orthogonal pair exists. Assume that there exist orthogonal vectors aL⊎aH∈A and bL⊎bH∈B. Then aL⊎bH is contained in both SA and SB. For the converse, assume that xL⊎xH∈SA∩SB. Since xL⊎xH∈SA, there exists aL⊎aH∈A such that xL=aL and xH∩aH=βˆ…. Similarly, since xL⊎xH∈SB, there exists bL⊎bH∈B such that bH=xH and bL∩xL=βˆ…. Hence, aL∩bL=βˆ… and aH∩bH=βˆ….

Observe that both |SA| and |SB| are at most 2d/2β‹…(|A|+|B|), so in π’ͺ~⁒(2d/2β‹…n) time we can construct SA and SB, and check whether SA∩SBβ‰ βˆ…. β—€

3 Algorithm for Orthogonal Vectors (𝟐-OV)

Theorem 1.1. [Restated, see original statement.]

The Orthogonal Vectors problem can be solved in π’ͺ~⁒(1.25dβ‹…n) time by a randomized, one-sided error algorithm that succeeds with probability 1βˆ’2βˆ’dΩ⁒(1). Using computer-aided evaluation, the running time can be improved to π’ͺ⁒(1.16dβ‹…n).

The algorithm of ˜1.1 first randomly partitions the universe u=[d] into β„“ sets u1,…,uβ„“ of equal size and samples random families Ci of subsets of ui. We will show that if there exists a∈A and b∈B such that a∩b=βˆ…, then with sufficiently high probability the families C1,…,Cβ„“ contain a witness of the existence of a and b. Finally, we introduce auxiliary families LiβŠ†Ci and RiβŠ†Ci that allow us to efficiently find this witness, if it exists.

In the following, we assume that there exist a∈A and b∈B with a∩b=βˆ…. Let Ξ±,β∈[0,1] be real numbers such that |a|=Ξ±β‹…d and |b|=Ξ²β‹…d. Note that we can guess the values of Ξ± and Ξ² in poly⁒(d) time. Hence, from now on, we assume that we know the values of Ξ± and Ξ² precisely. Moreover, we can assume without loss of generality that Ξ±β©½Ξ² (by swapping A and B) and Ξ±+Ξ²β©½1 (as otherwise, the answer is trivially negative).

3.1 Partition of the universe

Let β„“ be a sufficiently large constant (for the sake of presentation we use β„“=100). By padding, we can assume that d,α⁒d and β⁒d are multiples of β„“. Consider a random partition of the universe u=[d] into β„“ parts u1,…,uβ„“ of equal cardinality such that [d]=u1βŠ”β€¦βŠ”uβ„“ and |ui|=d/β„“ for every i∈[β„“]. We observe that with sufficiently high probability, the solution is partitioned equally among ui.

Observation 3.1.

Let a∈A and b∈B with |a|=α⁒d and |b|=β⁒d. With probability at least dβˆ’π’ͺ⁒(β„“), for every i∈[β„“] it holds that:

|ui∩a|=α⁒dℓ⁒ and ⁒|ui∩b|=β⁒dβ„“.

Proof.

We focus on bounding the probability that |ui∩a|=α⁒dβ„“ for every i∈[β„“], as the reasoning for b is symmetric. For fixed integers k1,…,kβ„“β©Ύ0, the number of partitions of u into β„“ equal size sets such that |ui∩a|=ki for every i∈[β„“] is

(|a|k1,…,kβ„“)β‹…(|uβˆ–a|d/β„“βˆ’k1,…,d/β„“βˆ’kβ„“).

Since |a|=α⁒d, the number of partitions of u into β„“ equal size sets such that |ui∩a|=α⁒dβ„“ for every i∈[β„“] is

(α⁒dα⁒d/β„“,…,α⁒d/β„“)β‹…((1βˆ’Ξ±)⁒d(1βˆ’Ξ±)⁒d/β„“,…,(1βˆ’Ξ±)⁒d/β„“),

which can be lower bounded using Lemma 2.1 by

2h⁒(1/β„“,…,1/β„“)⁒dβ‹…dβˆ’π’ͺ⁒(β„“)=2(log2⁑ℓ)β‹…dβ‹…dβˆ’π’ͺ⁒(β„“)=β„“d⁒dβˆ’π’ͺ⁒(β„“).

On the other hand, the number of partitions of u into β„“ equal size sets is at most β„“d. Hence

ℙ⁒[|ui∩a|=α⁒dℓ⁒ for every ⁒i∈[β„“]]β©Ύβ„“d⁒dβˆ’π’ͺ⁒(β„“)β‹…β„“βˆ’d=dβˆ’π’ͺ⁒(β„“).

β—€

3.2 Certificate of orthogonality

Let Ξ»=λ⁒(Ξ±,Ξ²)∈[0,1] and ΞΊ=κ⁒(Ξ±,Ξ²) be parameters to be tuned later that only depend on Ξ± and Ξ². For every i∈[β„“], we randomly draw a family Ci of 2κ⁒|ui|β‹…dc subsets of ui of size λ⁒|ui|, for some sufficiently large constant c, i.e. we let

CiβŠ†R(uiΞ»β‹…|ui|)⁒ such that ⁒|Ci|=2ΞΊβ‹…|ui|β‹…dc. (2)
Definition 3.2 (Certificate of Orthogonality).

A tuple (c1,…,cβ„“)∈C1Γ—β‹―Γ—Cβ„“ is a certificate of orthogonality if

  1. (a)

    There exists a∈A such that for every i∈[β„“] it holds that a∩uiβŠ†ci, and

  2. (b)

    There exists b∈B such that for every i∈[β„“] it holds that b∩ci=βˆ….

Clearly, if there exists a certificate of orthogonality, then there exists a∈A and b∈B with a∩b=βˆ…. However, the converse is not necessarily true. We prove that for sufficiently many sets in each Ci (i.e. large enough parameter ΞΊ), if there exists a∈A and b∈B with a∩b=βˆ…, then with sufficiently high probability there exists a certificate of orthogonality in (C1,…,Cβ„“).

Lemma 3.3.

Assume that there exist disjoint a∈A and b∈B with |a|=α⁒d and |b|=β⁒d. If

Ξ» ∈[Ξ±,1βˆ’Ξ²]⁒ and
ΞΊ β©Ύh⁒(Ξ»)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²),

then with probability at least dβˆ’π’ͺ⁒(β„“) there exists a certificate of orthogonality in C1Γ—β‹―Γ—Cβ„“.

Proof.

We condition on the event that |a∩ui|=α⁒|ui| and |b∩ui|=β⁒|ui| for all i∈[β„“]. By ˜3.1, this happens with probability at least dβˆ’π’ͺ⁒(β„“).

Fix i∈[β„“]. First, we bound the probability that a set c sampled uniformly at random from (uiλ⁒|ui|) satisfies a∩uiβŠ†c and b∩c=βˆ…. The number of sets cβŠ†(uiλ⁒|ui|) that satisfy both properties is

((1βˆ’Ξ²βˆ’Ξ±)⁒|ui|(Ξ»βˆ’Ξ±)⁒|ui|).

Hence, since |ui|=d/β„“ and using Equation 1, the probability that cβŠ†R(uiλ⁒|ui|) satisfies properties both properties is at least

((1βˆ’Ξ±βˆ’Ξ²)⁒|ui|(Ξ»βˆ’Ξ±)⁒|ui|)β‹…(|ui|λ⁒|ui|)βˆ’1β©Ύ2((1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²)βˆ’h⁒(Ξ»))β‹…d/β„“β‹…dβˆ’π’ͺ⁒(1)

Hence if ΞΊβ©Ύh⁒(Ξ»)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²), then |Ci|β©Ύ1/p for

p≔2((1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²)βˆ’h⁒(Ξ»))β‹…d/β„“β‹…dβˆ’π’ͺ⁒(1).

Therefore, the probability that there exists c∈Ci satisfying both properties is at least 1βˆ’(1βˆ’p)1/pβ©Ύ1βˆ’eβˆ’1.

Finally, the probability that for every i∈[β„“] there exists c∈Ci such that a and b hold is at least (1βˆ’2βˆ’1)β„“ which is larger than success probability of ˜3.1 which is dβˆ’π’ͺ⁒(β„“). β—€

3.3 Auxiliary Families

In order to efficiently check if there exists a certificate of orthogonality in C1×…×Cβ„“, we introduce auxiliary families. For every i∈[β„“] and every set xβŠ†ui, define the following two families of sets of Ci:

L(i)⁒(x)≔{c∈Ci∣xβŠ†c}⁒ and ⁒R(i)⁒(x)≔{c∈Ci∣x∩c=βˆ…}. (3)
Claim 3.4.

The families L(i)⁒(x) and R(i)⁒(x) for every i∈[β„“] and every xβŠ†ui can be computed in π’ͺ⁒(β„“β‹…22⁒d/β„“) time.

Proof.

Since, for every i∈[β„“], the number of subsets xβŠ†ui is 2d/β„“, and the number of sets c in CiβŠ†2ui is at most 2d/β„“, the families of sets can be constructed by iterating over all i∈[β„“], all xβŠ†ui and all c∈Ci in time at most π’ͺ⁒(β„“β‹…2d/β„“β‹…2d/β„“). ⊲

Lemma 3.5.

For a fixed a∈A with |a|=α⁒d, with probability at least dβˆ’π’ͺ⁒(β„“) it holds that:

|L(1)⁒(a∩u1)|β‹…|L(2)⁒(a∩u2)|⁒⋯⁒|L(β„“)⁒(a∩uβ„“)|β©½2cAβ‹…dβ‹…dπ’ͺ⁒(β„“),

where cA≔(1βˆ’Ξ±)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±)βˆ’h⁒(Ξ»)+ΞΊ.

Proof.

We condition on the event that |a∩ui|=α⁒|ui| for all i∈[β„“], which happens with probability at least dβˆ’π’ͺ⁒(β„“) by ˜3.1. We first prove that for any i∈[β„“] and any xβŠ†ui with |x|=Ξ±β‹…|ui| it holds that

𝔼⁒[|L(i)⁒(x)|]β©½2cAβ‹…|ui|β‹…dπ’ͺ⁒(1). (4)

By definition, |L(i)⁒(x)| is the number of sets c∈Ci such that xβŠ†c. Since sets c∈Ci are subsets of ui drawn uniformly at random such that |c|=λ⁒|ui|, by Equation 1, the probability that xβŠ†c is

ℙ⁒[xβŠ†c]=((1βˆ’Ξ±)⁒|ui|(Ξ»βˆ’Ξ±)⁒|ui|)β‹…(|ui|λ⁒|ui|)βˆ’1β©½2((1βˆ’Ξ±)⁒h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±)βˆ’h⁒(Ξ»))β‹…|ui|.

By the linearity of expectation, this means that:

𝔼⁒[|L(i)⁒(x)|]=|Ci|⋅ℙ⁒[xβŠ†c]β©½2((1βˆ’Ξ±)⁒h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±)βˆ’h⁒(Ξ»))β‹…|ui|β‹…2ΞΊβ‹…|ui|β‹…dπ’ͺ⁒(1),

which establishes (4).

Now notice that for any i∈[β„“], by Markov inequality we have that

ℙ⁒[|L(i)⁒(x)|β©Ύ2⁒𝔼⁒[|L(i)⁒(x)|]]β©½1/2,

therefore the probability that we have |L(i)⁒(a∩ui)|<2⁒𝔼⁒[|L(i)⁒(a∩ui)|] for all i∈[β„“] is at least 1/2β„“β©Ύdβˆ’π’ͺ⁒(β„“). This directly implies that with probability at least dβˆ’π’ͺ⁒(β„“) we have

|L(1)⁒(a∩u1)|β‹…|L(2)⁒(a∩u2)|⁒⋯⁒|L(β„“)⁒(a∩uβ„“)|β©½2cAβ‹…dβ‹…dπ’ͺ⁒(β„“).

β—€

Similarly, one can prove:

Lemma 3.6.

For a fixed b∈B with |b|=β⁒d, with probability at least dβˆ’π’ͺ⁒(β„“) it holds that:

|R(1)⁒(b∩u1)|β‹…|R(2)⁒(b∩u2)|⁒⋯⁒|R(β„“)⁒(b∩uβ„“)|β©½2cBβ‹…dβ‹…dπ’ͺ⁒(β„“),

where cB≔(1βˆ’Ξ²)β‹…h⁒(1βˆ’Ξ»βˆ’Ξ²1βˆ’Ξ²)βˆ’h⁒(Ξ»)+ΞΊ.

Proof.

The proof is similar as for Lemma 3.5 by observing that, for every i∈[β„“]

ℙ⁒[x∩c=βˆ…]=((1βˆ’Ξ²)⁒|ui|λ⁒|ui|)β‹…(|ui|λ⁒|ui|)βˆ’1,

for sets x,cβŠ†ui with |x|=β⁒|ui| and |c|=λ⁒|ui|. β—€

3.4 Algorithm

Now, with L(i) and R(i) in hand, we can present the algorithm given in pseudocode in Algorithm 1. First, we construct a set Candidates of tuples in C1Γ—β‹―Γ—Cβ„“ that satisfy property a. We do this by iterating over every set a∈A and for such a we iterate over every (c1,…,cβ„“)∈L(1)⁒(a∩u1)Γ—β‹―Γ—L(β„“)⁒(a∩uβ„“) and add it to the set Candidates.

Clearly, after this step, every set that satisfies a is in Candidates. Now, our goal is to decide if there exists at least one tuple in Candidates that additionally satisfies b. To do so, we iterate over every b∈B and then over every (c1,…,cβ„“)∈R(1)⁒(b∩u1)Γ—β‹―Γ—R(β„“)⁒(b∩uβ„“). If (c1,…,cβ„“)∈Candidates, then we know that there exists a certificate of orthogonality and immediately report that there exists an orthogonal pair. If none of the loops reported yes, at the end of the algorithm we report that there is no pair of orthogonal vectors.

Algorithm 1 Pseudocode of the algorithm of Lemma 3.7.

Finally, to simplify the analysis of Algorithm 1, we stop iterating over every candidate set in Line 8 and Line 11 if the number of iterations exceeds respectively 2cAβ‹…dβ‹…dπ’ͺ⁒(β„“) or 2cBβ‹…dβ‹…dπ’ͺ⁒(β„“) steps, where cA and cB are the constants defined in Lemmas 3.5 andΒ 3.6. When we break these loops, we do not add any sets to Candidates and immediately continue the loops.

This concludes the description of Algorithm 1. The following lemma certifies its correctness and bounds its running time in terms of the parameters α,β,λ⁒(α,β) and κ⁒(α,β). We then provide an analytical analysis of the running time by optimizing α and β.

Lemma 3.7.

Given A,BβŠ†2[d], there exists an

(2cAβ‹…d⁒|A|+2cBβ‹…d⁒|B|+β„“β‹…22⁒d/β„“)β‹…dπ’ͺ⁒(β„“)

time randomized, one-sided error algorithm with 1βˆ’2βˆ’dΩ⁒(1) probability of success that decides if there exist a∈A and b∈B such that a∩b=βˆ…, where cA and cB are as in Lemmas 3.5 andΒ 3.6.

Proof.

We repeat Algorithm 1 dπ’ͺ⁒(β„“) times and return true iff any execution returns true. Consider Algorithm 1. The preprocessing in Section 3.1 takes π’ͺ⁒(d) time. By ˜3.4, the construction of data structures L(1),…,L(β„“),R(1),…,R(β„“) takes π’ͺ⁒(β„“β‹…22⁒d/β„“) time. Finally, the for loops in Algorithm 1 take in total (2cAβ‹…d⁒|A|+2cBβ‹…d⁒|B|)β‹…dπ’ͺ⁒(β„“) time. This concludes the running time analysis. It remains to prove the correctness.

Note that if there do not exist any disjoint pairs in A and B, then Algorithm 1 never returns true. Hence, to bound the probability of false-negative, assume that a∈A and b∈B are orthogonal. By Lemma 3.3, with probability at least dβˆ’π’ͺ⁒(β„“), there exists a certificate of orthogonality in C1Γ—β‹―Γ—Cβ„“ for a and b. By Lemmas 3.5 andΒ 3.6, with probability at least dβˆ’π’ͺ⁒(β„“), the loop in Line 8 corresponding to a and the loop in Line 11 corresponding to b are fully executed. Observe that by Lemma 3.5, with probability at least dβˆ’π’ͺ⁒(β„“), the loop in Line 8 corresponding to a is fully executed. If that happens, the set Candidates contains every tuple (c1,…,cβ„“)∈L(1)⁒(a∩u1)Γ—β‹―Γ—L(β„“)⁒(a∩uβ„“). In particular, it contains the certificate of orthogonality for a and b. Moreover, by Lemma 3.6, with probability at least dβˆ’π’ͺ⁒(β„“), the loop in Line 11 corresponding to b is also fully executed. Hence this certificate will be detected and the algorithm returns true.

To conclude, if a∈A and b∈B are orthogonal, Algorithm 1 returns true with probability dβˆ’π’ͺ⁒(β„“). To guarantee probability of success 1βˆ’2βˆ’dΩ⁒(1), it suffices to repeat Algorithm 1 dπ’ͺ⁒(β„“) many times. β—€

Proof of ˜1.1.

Assume that there exist a∈A and b∈B such that a∩b= and let |a|=α⁒d and |b|=β⁒d for some α,β∈[0,1]. By Lemma 3.7, one can find the pair (a,b) in time

π’ͺ~⁒(2cAβ‹…d⁒|A|+2cBβ‹…d⁒|B|+β„“β‹…22⁒d/β„“),

where Ξ» and ΞΊ are parameters depending on Ξ± and Ξ² to be optimized, and cA and cB are constants depending on Ξ±, Ξ², Ξ» and ΞΊ. Note that we have selected β„“=100, so the last term is upper bounded by π’ͺ~⁒(1.25dβ‹…n). Therefore, it suffices to prove that for any Ξ±,Ξ², by properly selecting Ξ» and ΞΊ, we can bound 2cA⁒d+2cB⁒d by π’ͺ~⁒(1.25d).

First, observe that the constants cA and cB defined in Lemmas 3.5 andΒ 3.6 grow with the parameter ΞΊ. On the other hand, by Lemma 3.3, we need ΞΊβ©Ύh⁒(Ξ»)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²) for the correctness analysis in Lemma 3.7 to hold. Hence to minimise 2cA⁒d+2cB⁒d, we choose ΞΊ to be minimal, i.e. we set κ≔h⁒(Ξ»)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²). Then we have

cA =(1βˆ’Ξ±)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²), (5)
cB =(1βˆ’Ξ²)β‹…h⁒(1βˆ’Ξ»βˆ’Ξ²1βˆ’Ξ²)βˆ’(1βˆ’Ξ±βˆ’Ξ²)β‹…h⁒(Ξ»βˆ’Ξ±1βˆ’Ξ±βˆ’Ξ²),

and using Lemma 2.1, we get the following bound

2cA⁒d+2cB⁒d β©½π’ͺ~⁒((((1βˆ’Ξ±)⁒d(Ξ»βˆ’Ξ±)⁒d)+((1βˆ’Ξ²)⁒d(1βˆ’Ξ»βˆ’Ξ²)⁒d))β‹…((1βˆ’Ξ±βˆ’Ξ²)⁒d(Ξ»βˆ’Ξ±)⁒d)βˆ’1).
So by setting λ≔(1+Ξ±βˆ’Ξ²)/2 and noticing that ((1βˆ’Ξ±βˆ’Ξ²)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2)βˆ’1β©½π’ͺ~⁒(2βˆ’(1βˆ’Ξ±βˆ’Ξ²)⁒d), we can further bound
2cA⁒d+2cB⁒d β©½π’ͺ~⁒((((1βˆ’Ξ±)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2)+((1βˆ’Ξ²)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2))β‹…((1βˆ’Ξ±βˆ’Ξ²)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2)βˆ’1)
β©½π’ͺ~⁒((((1βˆ’Ξ±)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2)+((1βˆ’Ξ²)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2))β‹…2βˆ’(1βˆ’Ξ±βˆ’Ξ²)⁒d).
Notice that both binomials select (1βˆ’Ξ±βˆ’Ξ²)⁒d/2 elements and recall that we assume Ξ±β©½Ξ². Hence the left term dominates the right term and by using Lemma 2.1 we bound the expression
2cA⁒d+2cB⁒d β©½π’ͺ~⁒(((1βˆ’Ξ±)⁒d(1βˆ’Ξ±βˆ’Ξ²)⁒d/2)β‹…2βˆ’(1βˆ’Ξ±βˆ’Ξ²)⁒d)
β©½π’ͺ~⁒(2h⁒((1βˆ’Ξ±βˆ’Ξ²)/21βˆ’Ξ±)β‹…(1βˆ’Ξ±)⁒dβ‹…2βˆ’(1βˆ’Ξ±βˆ’Ξ²)⁒d)
=π’ͺ~⁒(2h⁒(12βˆ’Ξ²2⁒(1βˆ’Ξ±))β‹…(1βˆ’Ξ±)⁒dβˆ’(1βˆ’Ξ±βˆ’Ξ²)⁒d)=π’ͺ~⁒(2(h⁒(12βˆ’Ξ²2⁒(1βˆ’Ξ±))βˆ’1)β‹…(1βˆ’Ξ±)⁒d+β⁒d).

The term involving Ξ±, that is (h⁒(12βˆ’Ξ²2⁒(1βˆ’Ξ±))βˆ’1)β‹…(1βˆ’Ξ±)⁒d, is maximized when Ξ±=0. This setting allows Ξ² to take any value in [0,1]. Hence the above term is maximized when Ξ±=0 and β∈[0,1] is maximizing h⁒(1/2+Ξ²/2)βˆ’1+Ξ². The derivative is (log2⁑(4βˆ’4⁒β)βˆ’log2⁑(Ξ²+1))/2, therefore we conclude that this expression has a single local maximum at Ξ²=3/5. In that case, the running time is bounded by:

π’ͺ~⁒(2(h⁒(1/5)βˆ’1+3/5)β‹…dβ‹…n)=π’ͺ~⁒(1.25dβ‹…n).

β—€

β–ΆΒ Remark 3.8.

The computer evaluation suggests that the maximum is obtained for the choice Ξ±=Ξ²=1/3, for which the best Ξ»=1/2. See Figure 1. This choice yields the running time:

π’ͺ~⁒((43)d/2β‹…n)β©½π’ͺ⁒(1.16dβ‹…n).

4 Algorithm for π’Œ-Orthogonal Vectors (π’Œ-OV)

We now show that for every fixed kβ©Ύ2, there exists an algorithm for k-OV with π’ͺ⁒(2(1βˆ’Ξ΅k)β‹…dβ‹…n) running time, where Ξ΅k>0 is a constant depending only on k. We remark that Ξ΅k tends to 0 as k tends to infinity. This is consistent with the lower bound we present in ˜1.3.

Theorem 1.2. [Restated, see original statement.]

For every kβ©Ύ2, there exists Ξ΅k>0 such that the k-Orthogonal Vectors problem can be solved deterministically in time π’ͺ⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n).

To prove ˜1.2, we will need the following combinatorial algorithm that follows from [4, Theorem 1].

Lemma 4.1.

Let kβˆˆβ„• be a fixed integer. Given A1,…,AkβŠ†2[d], we can count the number of tuples (a1,…,ak)∈A1Γ—β‹―Γ—Ak such that a1∩a2βˆ©β€¦βˆ©ak=βˆ… in time at most π’ͺ(dβ‹…(|↓A1|+…+|↓Ak|)).

Proof.

This directly follows from [4, Theorem 1] extended to k families. For completeness, we detail the proof here.

Let #⁒OV be the number of solutions for the given instance, i.e. the number of tuples (a1,…,ak)∈A1Γ—β‹―Γ—Ak such that a1βˆ©β‹―βˆ©ak=βˆ…. We can express #⁒OV as follows, where the second equality comes from the fact that any non-empty set has as many subsets of even size as subsets of odd size.

#⁒OV =βˆ‘a1∈A1βˆ‘a2∈A2β€¦βˆ‘ak∈Ak⟦a1∩a2βˆ©β‹―βˆ©ak=βˆ…βŸ§
=βˆ‘a1∈A1βˆ‘a2∈A2β€¦βˆ‘ak∈Akβˆ‘xβŠ†[d](βˆ’1)|x|β‹…βŸ¦xβŠ†a1∩a2βˆ©β‹―βˆ©ak⟧
=βˆ‘xβŠ†[d](βˆ’1)|x|βˆ‘a1∈A1βˆ‘a2∈A2β€¦βˆ‘ak∈Ak⟦xβŠ†a1βŸ§β‹…βŸ¦xβŠ†a2βŸ§β€¦βŸ¦xβŠ†ak⟧
=βˆ‘xβˆˆβ‹ƒi=1k↓Ai(βˆ’1)|x|β‹…f1⁒(x)β‹…f2⁒(x)⁒⋯⁒fk⁒(x)

where fi(x)β‰”βˆ‘a∈Ai⟦xβŠ†a⟧ for i∈[k]. For each i∈[k], we compute the values of fi⁒(β‹…) for all xβˆˆβ†“Ai in time π’ͺ(dβ‹…|↓Ai|) as follows. For each element j∈{0,1,…,d} and subset xβˆˆβ†“Ai define gj⁒(x) to be the number of sets a∈Ai such that xβŠ†a and a∩{1,2,…,j}=x∩{1,2,…,j}. In particular, g0⁒(x)=fi⁒(x) and gd(x)=⟦x∈Ai⟧. By induction on j, we can prove that

gjβˆ’1(x)=⟦jβˆ‰xβŸ§β‹…gj(x)+⟦xβˆͺ{j}βˆˆβ†“AiβŸ§β‹…gj(xβˆͺ{j}).

Using this recurrence relation, we can compute gj⁒(x) for all xβˆˆβ†“Ai and for all j∈{0,1,…,d}, and thus in particular fi⁒(x), in time π’ͺ(d|↓Ai|). By repeating this for every i∈[k] and using the above formula for #⁒OV, we can count the number of k-OV solutions in time π’ͺ(dβ‹…(|↓A1|+β‹―+|↓Ak|)). β—€

Proof of ˜1.2.

Fix kβ©Ύ3 and let 0<Ξ΅kβ©½1/2 be a parameter depending only on k that we define later. Consider a k-OV instance A1,…,AkβŠ†2[d]. Note that if the down-closures of A1,…,Ak are all small enough, i.e. of size at most π’ͺ⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n), then Lemma 4.1 provides the desired running time. If this is not the case, then we reduce the k-OV instance to a kβ€²-OV instance for smaller kβ€²<k. Since Lemma 2.2 proves the statement for k=2 with value Ξ΅2=1/2, we only need to show that Ξ΅k stays positive.

Assume that there exists a solution (a1,…,ak)∈A1Γ—β‹―Γ—Ak such that a1βˆ©β‹―βˆ©ak=βˆ…. Let Ξ±1,…,Ξ±k∈[0,1] be such that |ai|=Ξ±i⁒d for every i∈[k]. By enumerating all possible sizes, we can guess the values of Ξ±1,…,Ξ±k in π’ͺ⁒(dk) time. This factor will be negligible compared to 2(1βˆ’Ξ΅k)⁒d as kβ©Ύ2 is a fixed constant. After guessing Ξ±1,…,Ξ±k, we assume that the family Ai contains only sets of cardinality exactly Ξ±i⁒d for every i∈[k]. Next, we distinguish between two cases.

If Ξ±iβ©½(1βˆ’Ξ΅k) for every i∈[k], then the size of the down-closure of Ai is |↓Ai|=π’ͺ(2Ξ±i⁒dβ‹…|Ai|). Using the algorithm of Lemma 4.1, we solve the k-OV instance A1,…,Ak in time π’ͺ⁒(2(1βˆ’Ξ΅k)⁒dβ‹…nβ‹…d).

If there exists i∈[k] such that Ξ±i>(1βˆ’Ξ΅k), then we recurse as follows. By reordering the families, we can assume that Ξ±1β©½β‹―β©½Ξ±k. Let β„“βˆˆ[k] be the smallest index such that Ξ±β„“>(1βˆ’Ξ΅k), i.e. Ξ±1β©½β‹―β©½Ξ±β„“βˆ’1β©½(1βˆ’Ξ΅k)<Ξ±β„“β©½β‹―β©½Ξ±k. Note that (aβ„“,…,ak)∈Aβ„“Γ—β‹―Γ—Ak. Furthermore, for every i∈{β„“,…,k}, since Ξ΅kβ©½1/2, we can bound |Ai|β©½βˆ‘j=(1βˆ’Ξ΅k)⁒dd(dj)β©½(d(1βˆ’Ξ΅k)⁒d)β‹…d=(dΞ΅k⁒d)β‹…d. By Equation 1 we thus get |Ai|β©½2h⁒(Ξ΅k)⁒dβ‹…d. Hence we can enumerate Aβ„“Γ—β‹―Γ—Ak to guess the sets aβ„“,…,ak in time π’ͺ⁒(2h⁒(Ξ΅k)⁒d⁒(kβˆ’β„“+1)). To find the remaining sets a1,…,aβ„“βˆ’1, observe that we can restrict the universe to r≔aβ„“βˆ©β‹―βˆ©ak as we have a1βˆ©β‹―βˆ©ak=a1βˆ©β‹―βˆ©aβ„“βˆ’1∩r=(a1∩r)βˆ©β‹―βˆ©(aβ„“βˆ’1∩r). So we recursively solve the (β„“βˆ’1)-OV instance A1r,…,Aβ„“βˆ’1r where Air≔{a∩r∣a∈Ai} for all i∈{1,…,β„“βˆ’1}. By induction, this takes time π’ͺ~⁒(2(1βˆ’Ξ΅β„“βˆ’1)⁒dβ‹…n). In total, we solve the k-OV instance A1,…,Ak in time π’ͺ~⁒(2h⁒(Ξ΅k)⁒d⁒(kβˆ’β„“+1)β‹…2(1βˆ’Ξ΅β„“βˆ’1)⁒dβ‹…n)=π’ͺ~⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n) for Ξ΅kβ©½Ξ΅β„“βˆ’1βˆ’h⁒(Ξ΅k)β‹…(kβˆ’β„“+1). Note that since Ξ΅kβ©½1/2, the function Ξ΅k↦Ρk+h⁒(Ξ΅k)β‹…(kβˆ’β„“+1) is increasing. Furthermore, limΞ΅kβ†’0+Ξ΅k+h⁒(Ξ΅k)β‹…(kβˆ’β„“+1)=0. Since Ξ΅2>0 by Lemma 2.2, we can set Ξ΅k to a positive value satisfying Ξ΅kβ©½min⁑{1/2,Ξ΅β„“βˆ’1βˆ’h⁒(Ξ΅k)β‹…(kβˆ’β„“+1)}. Achieving running time π’ͺ⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n), instead of π’ͺ~⁒(2(1βˆ’Ξ΅k)⁒dβ‹…n) follows directly by scaling all Ξ΅k (e.g. by 0.99). β—€

Figure 1: For different values of Ξ±,β∈[0,1], we optimize the value of λ⁒(Ξ±,Ξ²) to minimise the running time bound π’ͺ~⁒(xdβ‹…n) of our algorithm, where the base of the running time is x=max⁑{2cA,2cB}, and cA and cB are as in (5). The running time is maximized for Ξ±=Ξ²=1/3, for which the best found value for Ξ» is Ξ»=1/2, resulting in a running time base xβ©½1.16.

5 Faster π’Œ-Orthogonal Vectors under the Asymptotic Rank Conjecture

In the Set Cover problem, we are given a universe u, a set family F and a positive integer t. The goal is to determine if there exist t sets in F whose union is u. We say that a set family F is δ-bounded for some δ∈(0,1) if no set in F is larger than δ⁒|u|. Bjârklund et al. [3] showed that under the Asymptotic Rank Conjecture, Set Cover instances with δ-bounded set families can be solved faster than 2|u| time.

Theorem 5.1 (Theorem 1.2 [3]).

Let δ∈(0,1/4) be a fixed constant. Assuming the Asymptotic Rank Conjecture, there exist c>0 and Ξ΅>0, such that any Set Cover instance (u,F,t) where F is Ξ΄-bounded, can be solved deterministically in π’ͺ⁒((2βˆ’Ξ΅)|u|β‹…|u|c) time.

Notice, that the running time of the above theorem does not depend on |F| (which is upper bounded by (|u||u|/4)⩽(e⁒|u||u|/4)|u|/4<1.82|u|). In particular, it works even if |F|=(|u|δ⁒|u|). We exploit that fact to prove the following result, which eliminates the necessity for δ-boundedness.

Corollary 5.2.

Assuming the Asymptotic Rank Conjecture, there exist c>0 and Ξ΅>0, such that any Set Cover instance (u,F,t) can be solved in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…|u|β‹…(|u|+|F|)c) time.

Proof.

Let s1,…,st∈F be a solution to the given Set Cover instance, and cβ€²,Ξ΅β€² be the constants from Theorem 5.1. Let Ξ±=1/5. If |si|β©½Ξ±β‹…|u| for every i∈[t], then we can solve the Set Cover instance in π’ͺ⁒((2βˆ’Ξ΅β€²)|u|β‹…|u|cβ€²) time using Theorem 5.1, by considering only the sets of size at most Ξ±β‹…|u| in F.

Otherwise, there exists i∈[t] such that |si|>Ξ±β‹…|u|. By guessing si among the sets in F (which takes an extra π’ͺ⁒(|F|) factor in the running time), we can restrict the universe to uβ€²=uβˆ–si and solve the remaining (tβˆ’1)-Set Cover instance (uβ€²,Fβ€²,tβˆ’1), where Fβ€²={s∩uβ€²βˆ£s∈F}. As the size of the universe is |uβ€²|β©½(1βˆ’Ξ±)β‹…|u|, we can solve the remaining instance in 2(1βˆ’Ξ±)β‹…|u|β‹…(|u|+|F|)π’ͺ⁒(1) time by applying the standard dynamic programming algorithm for Set Cover (e.g. Theorem 6.1 in [10]), that runs in 2|uβ€²|β‹…(|uβ€²|+|Fβ€²|)π’ͺ⁒(1) time.

It follows that for sufficiently large c and sufficiently small Ξ΅>0, one can solve the Set Cover instance (u,F,t) in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…|u|β‹…(|u|+|F|)c) time. β—€

We now show an equivalence between Set Cover and k-Orthogonal Vectors in the setting of exact algorithms.

Theorem 5.3.

The following statements are equivalent:

  1. (a)

    There exist c>0 and Ξ΅>0, such that k-Orthogonal Vectors on n vectors in dimension d can be solved in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…dβ‹…nc) time (algorithm works uniformly for a given kβˆˆβ„•).

  2. (b)

    There exists c>0 and Ξ΅>0, such that Set Cover on a universe u and a set family F can be solved in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…|u|β‹…(|u|+|F|)c) time.

Proof.

Implication (a)

β‡’ (b). Let (u,𝐅,𝐭) be an instance of Set Cover. Let 𝒄>𝟎 and 𝜺>𝟎 be fixed constants such that 𝒕-Orthogonal Vectors is solvable in π“žβ’(𝟐(πŸβˆ’πœΊ)⋅𝒅⋅𝒏𝒄) time. Consider the instance π€πŸ,…,𝐀𝐭 of 𝒕-Orthogonal Vectors where π€πŸ=…=𝐀𝐭 and aβŠ†u is in π€πŸ iff uβˆ–aβˆˆπ…. Since we constructed |𝑭| vectors of dimension |u|, it suffices to show that there exists a solution for the Set Cover instance iff there exists a solution for the 𝒕-Orthogonal Vectors instance.

If there exists a solution a𝟏,…,a𝐭 for the 𝒕-Orthogonal Vectors instance, then β‹‚π’Š=πŸπ’•a𝐒=βˆ…, meaning that β‹ƒπ’Š=πŸπ’•uβˆ–a𝐒=u. But uβˆ–aπ’βˆˆπ… by construction, therefore uβˆ–a𝟏,…,uβˆ–a𝐭 is a solution for the Set Cover instance. Similarly, if there exists a solution s𝟏,…,s𝐭 for the Set Cover instance, then β‹ƒπ’Š=πŸπ’•s𝐒=u, meaning that β‹‚π’Š=πŸπ’•uβˆ–s𝐒=βˆ…. But uβˆ–sπ’βˆˆπ€π’ by construction, therefore uβˆ–s𝟏,…,uβˆ–s𝐭 is a solution for the 𝒕-Orthogonal Vectors problem.

Implication (a)

⇐ (b). Let (π‘¨πŸ,…,π‘¨π’Œ) be an instance of π’Œ-Orthogonal Vectors of dimension 𝒅 and let 𝒄>𝟎 and 𝜺>𝟎 be fixed constants such that Set Cover is solvable in π“žβ’(𝟐(πŸβˆ’πœΊ)β‹…|u|β‹…(|u|+|𝐅|)𝐜) time. Consider the instance (u,𝐅,𝐭) of Set Cover where π’•β‰”π’Œ, u≔[𝐝+𝐀], and π…β‰”β‹ƒπ’βˆˆ[𝐀]𝐅𝐒, where 𝐅𝐒≔{{𝐝+𝐒}βˆͺ([𝐝]βˆ–a)∣aβˆˆπ€π’}. Since π’Œ is a constant, the size of the universe is |u|=𝐝+π“žβ’(𝟏) and 𝑭=π“žβ’(𝒏). Hence, the running time of the Set Cover algorithm is π“žβ’(𝟐(πŸβˆ’πœΊ)⋅𝒅⋅𝒏𝒄). It suffices to show that there exists a solution for the π’Œ-Orthogonal Vectors instance iff there exists a solution for the constructed Set Cover instance.

Let a𝟏,…,a𝐀 be a solution for the π’Œ-Orthogonal Vectors instance. Then β‹‚π’Š=πŸπ’Œa𝐒=βˆ…, meaning that β‹ƒπ’Š=πŸπ’Œ[𝒅]βˆ–a𝐒=[𝐝]. Therefore, the sets {{𝒅+π’Š}βˆͺ([𝒅]βˆ–a𝐒)∣𝐒∈[𝐀]} cover the universe u, and thus there exists a solution for the Set Cover instance. Similarly, let s𝟏,…,s𝐀 be a solution for the Set Cover instance. As 𝒕=π’Œ and for every π’Šβˆˆ[π’Œ] it holds that {𝒅+π’Š}∈s iff sβˆˆπ…π’, we can assume that sπ’βˆˆπ…π’ for every π’Šβˆˆ[π’Œ]. Because s𝟏,…⁒s𝐀 is a valid cover, we have β‹ƒπ’Š=πŸπ’Œs𝐒=u, and thus β‹ƒπ’Š=πŸπ’Œ(sπ’βˆ–{𝐝+𝐒})=[𝐝]. Therefore β‹‚π’Š=πŸπ’Œ[𝒅]βˆ–s𝐒=βˆ…, meaning that the sets {uβˆ–s𝐒∣𝐒∈[𝐀]} are a solution for the π’Œ-Orthogonal Vectors instance. β—€

The faster algorithm for k-Orthogonal Vectors follows directly from Corollary 5.2 and Theorem 5.3.

Theorem 1.4. [Restated, see original statement.]

Assuming the Asymptotic Rank Conjecture, there exist c>0 and Ξ΅>0, such that any k-Orthogonal Vectors instance can be solved in π’ͺ⁒(2(1βˆ’Ξ΅)β‹…dβ‹…nc) time for every kβˆˆβ„•.

On the other hand, the Set Cover Conjecture implies that there is no Ξ΅>0 for which Set Cover is solvable in π’ͺ⋆⁒(2(1βˆ’Ξ΅)β‹…|u|) time. In particular, Theorem 5.3 implies the lower bound for k-Orthogonal Vectors stated in ˜1.3, based on the Set Cover Conjecture (which is incompatible with the Asymptotic Rank Conjecture [5]).

Theorem 1.3. [Restated, see original statement.]

For every c>0 and Ξ΅>0, there exists kβˆˆβ„• such that the k-Orthogonal Vectors problem is not solvable in π’ͺ⁒(2(1βˆ’Ξ΅)⁒dβ‹…nc) time, assuming the Set Cover Conjecture.

References

  • [1] Amir Abboud, Ryan Williams, and Huacheng Yu. More applications of the polynomial method to algorithm design. In Proceedings of the Twenty-sixth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’15, pages 218–230. Society for Industrial and Applied Mathematics, 2015. URL: http://dl.acm.org/citation.cfm?id=2722129.2722146.
  • [2] Josh Alman and Baitian Li. Kronecker Powers, Orthogonal Vectors, and the Asymptotic Spectrum. In 66th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2025, pages 1411–1441. IEEE, 2025. doi:10.1109/FOCS63196.2025.00074.
  • [3] Andreas BjΓΆrklund, Radu Curticapean, Thore Husfeldt, Petteri Kaski, and Kevin Pratt. Fast deterministic chromatic number under the asymptotic rank conjecture. In Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2025, pages 2804–2818. SIAM, 2025. doi:10.1137/1.9781611978322.91.
  • [4] Andreas BjΓΆrklund, Thore Husfeldt, Petteri Kaski, and Mikko Koivisto. Counting Paths and Packings in Halves. In Amos Fiat and Peter Sanders, editors, Algorithms - ESA 2009, 17th Annual European Symposium. Proceedings, 2009.
  • [5] Andreas BjΓΆrklund and Petteri Kaski. The Asymptotic Rank Conjecture and the Set Cover Conjecture Are Not Both True. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, pages 859–870. ACM, 2024. doi:10.1145/3618260.3649656.
  • [6] Timothy M. Chan and Ryan Williams. Deterministic APSP, Orthogonal Vectors, and More: Quickly Derandomizing Razborov-Smolensky. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2016, pages 1246–1255. SIAM, 2016. doi:10.1137/1.9781611974331.CH87.
  • [7] Lijie Chen and Ryan Williams. An Equivalence Class for Orthogonal Vectors. In Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, 2019.
  • [8] Nikolai Chukhin, Alexander S. Kulikov, Ivan Mihajlin, and Arina Smirnova. Conditional complexity hardness: Monotone circuit size, matrix rigidity, and tensor rank under NSETH and beyond. Electron. Colloquium Comput. Complex., TR25-038, 2025. URL: https://eccc.weizmann.ac.il/report/2025/038.
  • [9] Imre CsiszΓ‘r and Paul C Shields. Information theory and statistics: A tutorial. Now Publishers Inc, 2004.
  • [10] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, DΓ‘niel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [11] Fedor V. Fomin, Daniel Lokshtanov, Fahad Panolan, and Saket Saurabh. Efficient Computation of Representative Families with Applications in Parameterized and Exact Algorithms. J. ACM, 63(4):29:1–29:60, 2016. doi:10.1145/2886094.
  • [12] Jiawei Gao, Russell Impagliazzo, Antonina Kolokolova, and Ryan Williams. Completeness for First-order Properties on Sparse Structures with Algorithmic Applications. ACM Trans. Algorithms, 15(2):23:1–23:35, 2019. doi:10.1145/3196275.
  • [13] Jesper Nederlof and Karol WΔ™grzycki. Improving Schroeppel and Shamir’s algorithm for Subset Sum via Orthogonal Vectors. In STOC ’21: 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 1670–1683. ACM, 2021. doi:10.1145/3406325.3451024.
  • [14] Kevin Pratt. A Stronger Connection between the Asymptotic Rank Conjecture and the Set Cover Conjecture. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, pages 871–874. ACM, 2024. doi:10.1145/3618260.3649620.
  • [15] Timothy W. Randolph and Karol WΔ™grzycki. Beating Meet-in-the-Middle for Subset Balancing Problems. CoRR, abs/2511.10823, 2025. doi:10.48550/arXiv.2511.10823.
  • [16] Herbert Robbins. A remark on Stirling’s formula. The American mathematical monthly, 62(1):26–29, 1955.
  • [17] Ryan Williams. A new algorithm for optimal 2-constraint satisfaction and its implications. Theor. Comput. Sci., 348(2-3):357–365, 2005. doi:10.1016/J.TCS.2005.09.023.
  • [18] Ryan Williams. The Orthogonal Vectors Conjecture and Non-Uniform Circuit Lower Bounds. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, pages 1372–1387. IEEE, 2024. doi:10.1109/FOCS61266.2024.00088.
  • [19] Virginia Vassilevska Williams. Hardness of Easy Problems: Basing Hardness on Popular Conjectures such as the Strong Exponential Time Hypothesis (Invited Talk). In IPEC 2015, pages 17–29, 2015. doi:10.4230/LIPIcs.IPEC.2015.17.