Parameterized Fine-Grained Reductions

TL;DR

This paper introduces a parameterized framework for fine-grained reductions, enabling a deeper analysis of problem structures and fixed-parameter improvements, exemplified by a sub-quadratic algorithm for the orthogonal vectors problem.

Contribution

It proposes a unified parameterized approach to fine-grained reductions, defines the class FPI for problems with fixed-parameter improvements, and provides a circuit characterization for FPI.

Findings

Developed a parameterized framework for fine-grained reductions.

Established FPI as a class of problems with fixed-parameter improvements.

Presented a sub-quadratic fixed-parameter algorithm for the orthogonal vectors problem.

Abstract

During recent years the field of fine-grained complexity has bloomed to produce a plethora of results, with both applied and theoretical impact on the computer science community. The cornerstone of the framework is the notion of fine-grained reductions, which correlate the exact complexities of problems such that improvements in their running times or hardness results are carried over. We provide a parameterized viewpoint of these reductions (PFGR) in order to further analyze the structure of improvable problems and set the foundations of a unified methodology for extending algorithmic results. In this context, we define a class of problems (FPI) that admit fixed-parameter improvements on their running time. As an application of this framework we present a truly sub-quadratic fixed-parameter algorithm for the orthogonal vectors problem. Finally, we provide a circuit characterization for FPI to further solidify the notion of improvement.

Tables

Table 1. Table 1 : Some reductions using our notation ( where APNT abbreviates the All-Pairs Negative Triangle problem, NegTr the Negative Triangle, and MPProd the Min-Plus product problem. )

Equations

$$\sum _{i=1}^{k(n)}{b}^{1-\epsilon }(n_i)\le d\cdot a^{1-\delta }(n)$$

$$a^{1-\delta }(n)+\sum _{i=1}^q{b}^{1-{\epsilon }^{\prime }}(n)f({\lambda }_1,\dots ,{\lambda }_{|\Lambda |})=a^{1-\delta }(n)+\sum _{i=1}^q{b}^{1-{\epsilon }^{\prime }}(n)f(h(k_1,\dots ,k_{|K_{\Lambda }|}))$$

$$\le a^{1-\delta }(n)\cdot f^{\prime }(k_1,\dots ,k_{|K_{\Lambda }|})$$

$$(d+1{)}^2(n+d){\log }^{d+1-1}(n+d)=O\left(d^2(n+d){\log }^d(n+d)\right)$$

$$S^{\prime }(n)$$

$$=a^{1-\epsilon }(n)\left(f(k_1,\dots ,k_{|K|})\log a^{1-ϵ}(n)+f(k_1,\dots ,k_{|K|})\log (f(k_1,\dots ,k_{|K|}))\right)$$

$$=a^{1-\epsilon }(n)\log a^{1-\epsilon }(n)f^{\prime }(k_1,\dots ,k_{|K|})\le a^{1-\epsilon }(n)a^{\delta }(n)f^{\prime }(k_1,\dots ,k_{|K|})\text{, for any }\delta >0.$$

Full text

1 Introduction

Fine-Grained Complexity deals with the exact complexity of problems, and establishes a web of refined reductions, that preserve exact solving times. While many of the key ideas come from well-known frameworks (NP-completeness program, parameterized algorithms and complexity, etc.), this significant new perspective has emerged only recently [23].

The main question posed by this new field is “given a problem known to be solvable in $t(n)$ time, is there an $\varepsilon>0$ such that it can be solved in $t^{1-\varepsilon}(n)$?”. In the case such a result exists, we can connect this improvement to algorithmic advances among different problems. In the case it does not, we can establish conditional lower bounds based on this hardness, as is usually done with popular conjectures [6, 24]. Several such conjectures are used, such as the Orthogonal Vectors Conjecture (OVC), the Strong Exponential Time Hypothesis (SETH), the APSP conjecture etc. It has been shown that OVC is implied by SETH [22], and the variants and consequences of both conjectures have been extensively studied.

A main difference between the fine-grained approach and classical complexity theory is that all NP-complete problems form an equivalence class modulo polynomial-time reductions. On the contrary, fine-grained reductions produce a much more complex web. Many problems stem from SETH/OVC, others from the 3-SUM conjecture (especially Computational Geometry problems [15]), and very few equivalence classes are known (a significant exception is the equivalence class for APSP [3], [24]). These observations raise questions concerning the structural complexity of fine-grained reducibility, as has traditionally been the case in other fields of complexity theory: Conditional irreducibility results, the morphology of the equivalence classes formed, fine-grained completeness notions, consequences of partitioning problems into classes etc., propose a fine-grained structural complexity program.

On the other hand, the parameterized point of view is dominant in theoretical computer science during the last decades. ETH and SETH were introduced in that context, and used widely to establish conditional lower bounds (SETH-hardness). Additionally, Fixed Parameter Tractability (FPT)111A problem is called Fixed Parameter Tractable, if there is a parameterization $k$ such that the problem can be solved in time $f(k)\cdot poly(n)$, for a computable function $f$., gave a multi-variable view of complexity theory, as well as the means to concentrate the hardness of problems to a certain parameter, instead of the input size: many problems have significant improvements on their complexity, if one restricts them to instances having fixed $k$, where $k$ is a parameter of the aforementioned problems. This can be viewed as an indication of the structural importance of $k$ in each problem.

Similar techniques can be used to differentiate versions of problems, as has been seen recently in the case of fine-grained conjectures (e.g. problems on sparse graphs [17]).

1.1 Motivation

The conditional bounds shown by fine-grained reductions stem from relating improvements between the conjectured best running times of two problems. This has resulted in an effort to classify problems either through equivalence or hardness via a minimal element (OV-hardness) [11].

Additionally, most known fine-grained reductions inherently relate the problems in more than trivial ways, also mapping specific parameters of each problem to one another. This could indicate relations between the problems’ property of concentrating hardness to certain parameters.

On the other hand, while parameterized complexity has traditionally been concerned with breaching the gap between polynomial and exponential running times, there has recently been interest in fixed-parameter improvements amongst polynomial time problems (sometimes referred to as FPT in P [23, 18]).

The ability of fine-grained complexity to express correlations between problems of various running times, comes with some inherent theoretical obstacles. Specifically, the new viewpoint of a problem’s "hardness" is associated with the capability to improve its running time. This results in a "counter-intuitive" notion of hard problems, as they frequently correspond to (in classical terms) easy ones. Moreover, the foundation on which this framework is based, allows the computational resources of a fine-grained reduction to change depending on the participant problems. This produces vagueness regarding what would be considered a complexity class compatible with such reductions.

Our concern is to surpass the inherent difficulties of the field towards constructive methods that produce generalizable results, as well as to contribute to the effort of establishing structural foundations for the framework. This could result in furthering our understanding of what constitutes difficulty in computation, as well as to structurally define improvability.

1.2 Our Results

We introduce Parameterized Fine-Grained Reductions (PFGR), a parameterized approach to fine-grained reducibility that is consistent with known fine-grained reductions and offers (a) tools to study structural correlations between problems, and (b) an extension to the suite of results that are obtained through the reductions. This provides a multi-variate approach of analyzing fine-grained reductions. Additionally, we give evidence that these reductions connect structural properties of the problems, such as the aforementioned concentration of hardness.

We define a class of problems (FPI) that admit parameterized improvements on their respective conjectured best running time algorithms. To this end, we treat improvements in the same way as fine-grained complexity (i.e. excluding polylogarithmic improvements in the running time). This gives us the expressive power to correlate structural properties of problems that belong in different complexity classes.

We prove that this class is closed under the aforementioned parameterized fine-grained reductions, which can be used as a tool to produce non-trivial parameterized algorithms (via the reduction process). We present such an application in the case of the reduction from OV to Diameter, in which we use a fixed parameter (with respect to treewidth) algorithm for Diameter to produce a new sub-quadratic fixed parameter algorithm for OV running in time $O\left(d^{2}(n+d)\log^{d}(n+d)\right)$ where $d$ is the dimension of the input vectors.

Finally, we use notions from parameterized circuit complexity to analyze membership in this class and introduce a circuit characterization, similar to the one used in the definition of the W-Hierarchy in parameterized complexity [13].

1.3 Related Work

The fine-grained reductions literature has quickly grown over the recent years (see [23] for a survey). The basis for reductions have been some conjectures that are widely considered to be true. Namely, the 3SUM, APSP, HITTING SET & SETH conjectures, which are associated with the respective plausibility for improvement of each problem.

A large portion of known reductions stem from the Orthogonal Vectors problem, which is known to be SETH-hard [22], thus OV plays a central role in the structure of the reductions web. Different versions of the OV conjecture were studied, usually parameterized by the dimension [2].

The logical expressibility of problems similar to OV were studied [17], research that created a notion of hardness for problems in first-order logic, and introduced various equivalence classes ([17, 16, 11]) concerning different versions of the OV problem, with significant applications to other fields (such as Computational Geometry). Additionally, the OV conjecture was studied in restricted models, such as branching programs [20].

Structural implications of fine-grained irreducibility and hypotheses were studied, culminated to new conjectures, like NSETH [9]. New implications of refuting the aforementioned hypotheses on Circuit Lower Bounds were discovered [19, 4, 1], and the refutation of SETH would imply state-of-the-art lower bounds on non-uniform circuits. Recently, fine-grained hypotheses were connected to long-standing questions in complexity theory, such as Derandomization of Complexity Classes [10].

The parameterized analysis of algorithms, one of the most active areas in theoretical and applied computer science, has been frequently used to provide tools in fine-grained complexity. As such, new conjectures were formed about the solvability of polynomial-time problems in terms of parameters [5].

In a notable case of similar work [8], the authors analyze the multivariate (parameterized) complexity of the longest common subsequence problem (LCS), taking into account all of the commonly discussed parameters on the problem. As a result, they produce a general conditional lower bound accounting for the conjunction of different parameterized algorithms for LCS: Unless SETH fails, the optimal running time for LCS is $\left(n+min\{d,\delta\Delta,\delta m\}\right)^{1\pm o(1)}$ where $d,\delta,\Delta,m$ are the aforementioned parameters. Note that our work is in a different direction to this result. Instead of separately reducing SETH to each different parameterized case, we give the means to show correlations between parameters in such reductions, i.e. with this framework one can analyze a single reduction to show multiple dependencies between parameterized improvements for each problem. While this automatically produces several conditional bounds among parameterizations of problems, it proves most useful in the opposite direction, namely to transfer improvements between problems and thus derive new parameterized algorithms.

2 Preliminaries

We denote with $[n]$, for $n\in\mathbb{N}$, the set $\{1,\ldots,n\}$.

Definition 2.1** (Generalized Parameterized Languages).**

Let $L\subseteq\Sigma^{*}$, and $k_{1},\dots,k_{\ell}$ parameterization functions, $k_{i}:\Sigma^{*}\to\mathbb{N}$, $1\leq i\leq\ell$. Let $\langle L,k_{1},\dots,k_{\ell}\rangle$ denote the corresponding parameterized language.

For simplicity, we will use $\langle L\rangle$ to abbreviate $\langle L,k_{1},\dots,k_{\ell}\rangle$, and $I_{L}$ to denote an input instance for $\langle L\rangle$.

Note here the divergence from the classical definition, that associates each problem with only one parameter [13]. We prefer the generalized version that allows us to describe simultaneously several structural measures of the problem, such as number of variables, number of nodes and more complex ones. For each one of those parameters we assume that there exists an index $j\in\{1,\ldots\ell\}$ such that $k_{j}$ corresponds to the mapping of the input instance $I_{L}$ to this specific parameter. In this way we can not only isolate and analyze different characteristics of structures but also treat each of these measures individually.

Definition 2.2** (OV).**

Define the Orthogonal Vectors problem ($OV$) as follows: Given two sets $A,B\subseteq\{0,1\}^{d}$, with $|A|=|B|=n$, are there two vectors $a\in A$, $b\in B$, such that $a\cdot b=\sum_{i=1}^{d}a[i]\cdot b[i]=0$?

Definition 2.3** ($3/2$-Approx-Diameter).**

Given a graph $G=(V,E)$, approximate its diameter, i.e. the quantity $\max_{u,v\in V}d(u,v)$, within a factor $3/2$.

We will also define the notion of treewidth as we will later present a result that utilizes it as a graph parameter.

Definition 2.4** (Treewidth).**

A tree decomposition of a graph $G=(V,E)$ is a tree, $T$, with nodes $X_{1},X_{2}\ldots X_{n}$ (called bags), where each $X_{i}$ is a subset of $V$, satisfying the following properties:

• •

The union of all sets $X_{i}$ equals $V$. That is, each graph vertex is contained in at least one tree node.

• •

The tree nodes containing vertex v, form a connected subtree of T.

• •

For every edge $(v,w)$ in the graph, there is a subset $X_{i}$ that contains both $v$ and $w$.

The width of a tree decomposition is the size of its largest set $X_{i}$ minus one. The treewidth $tw(G)$ of a graph $G$ is the minimum width among all possible tree decompositions of $G$.

For more information on parameterized complexity, and treewidth the reader is referred to [13, 12].

We will utilize the following notions from circuit complexity theory (for more details the reader is referred to Ch. 6 of [7]).

Definition 2.5** (Circuit Complexity).**

The circuit-size complexity of a Boolean function ${\displaystyle f}$ is the minimal size (number of gates) of any circuit computing ${\displaystyle f}$. The circuit-depth complexity of a Boolean function ${\displaystyle f}$ is the minimal depth of any circuit computing ${\displaystyle f}$.

We will also use the following definition of Fine-Grained reductions from [24].

Definition 2.6** (Fine-Grained Reduction).**

Let $a(n),b(n)$ be nondecreasing functions of $n$. Problem $A$ is $(a,b)$-reducible to problem $B$ (denoted $A\leq_{FG}B$), if for all $\varepsilon>0$ there exists a $\delta>0$, and an algorithm $F$ solving $A$ with oracle access to $B$ such that $F$ runs in at most $d\cdot a^{1-\delta}(n)$ time, making at most $k(n)$ oracle queries adaptively (i.e. the $j^{th}$ instance $B_{j}$ is a function of $\{B_{i},a_{i}\}_{1\leq i<j}$). The sizes $|B_{i}|=n_{i}$ for any choice of oracle answers $a_{i}$, obey the inequality:

[TABLE]

3 Parameterized Fine-Grained Reductions

In this section we define Parameterized Fine-Grained Reductions (PFGR), along with some examples of applications, and show their relation to fine-grained reductions.

Definition 3.1** (PFGR).**

Given problems $A$ and $B$ with $a(n)$, $b(n)$ their respective conjectured best running times: We say $\langle A,k_{1},\dots,k_{i_{A}}\rangle\leq_{PFG}\langle B,\lambda_{1},\dots,\lambda_{i_{B}}\rangle$ if there exists and algorithm R such that

For every $\varepsilon>0$ there exists a $\delta>0$ such that R runs in $a^{1-\delta}(n)$ time on inputs $I_{A}$ of length $n$ by making $q$ query calls to $\langle B\rangle$ with query lengths $n_{1},\dots,n_{q}$, and $\sum_{i=1}^{q}b^{1-\varepsilon}(n_{i})\leq c\cdot a^{1-\delta}(n)$, for some constant $c>0$, and R accepts iff $I_{A}\in\langle A\rangle$. 2. 2.

*For every query $q_{j},j=1,\ldots,q$, there exists a computable function $g_{j}:\mathbb{N}^{i_{A}}\to\mathbb{N}^{i_{B}}$ defined as $g_{j}(k_{1},\ldots,k_{i_{A}})=[g_{j,1},g_{j,2},\ldots,g_{j,i_{B}}]$ such that for every *$\lambda_{i}\in\langle\lambda_{1},\dots,\lambda_{i_{B}}\rangle$

$\lambda_{i}\leq g_{j,i}(k_{1},\ldots,k_{i_{A}})$.

Remark 3.2**.**

The number of calls is specific to the type of reduction used. In the case of adaptive queries, the number of potential calls could exceed $q$ exponentially (in the worst case). A reasonable objection could arise here since the mappings $g_{j}$ are not assumed to have any time restriction. However, $g_{j}$ are not implemented by the reduction algorithm, and are merely correlating functions of the parameters. As such, they do not affect the running time of the reduction.

Additionally, one would suspect that this definition is a limitation on the original fine-grained framework and hence is only satisfied by some of the known reductions. The main problem is that most of the known reductions refer to non parameterized problems. This however can be easily surpassed by our formalization, as we can view these as projections of PFGR (see section 3):

Given a problem $P$ and an input instance $I_{P}$, the parameterized version of the problem can be produced by extending the input with the computable function that defines each parameter over it. We can now redefine any reductions it took place in, simply replacing the problem with its parameterized version. This essentially provides us with all of the possible parameterizations a problem can have, and uses them as a whole in order to preserve structural characteristics.

While analyzing reductions, some notable cases occur: Firstly, the case of only one query call, as observed in the majority of known fine-grained reductions. Secondly, the case where even though many query calls are made, the constructions of the input instance to $\langle B\rangle$ maintain uniform mappings of the parameters, i.e. $g_{j}=g_{j^{\prime}},\forall j,j^{\prime}\in[q]$. Lastly, the case where the value of each parameter of problem $\langle B\rangle$ is only related to a single parameter of $\langle A\rangle$, i.e. $g_{j,i}:\mathbb{N}\to\mathbb{N}$. 222this case is especially useful in transferring parameterized improvements, as we will see in section 4.7.

We provide some examples to further clarify our definition and notation:

Example 3.3**.**

Consider the well-studied reduction $CNF\mbox{-}SAT\leq_{2^{n},n^{2}}k\mbox{-}OV$, presented in [22]. It is apparent that through one call, the number of clauses $m$ of the SAT instance corresponds to the dimension $d$ of the OV vectors instance, as well as that the number of variables $n$ is mapped to the number of vectors $N$ via the mapping: $g(n,m)=\langle 2^{n/k},m\rangle=\langle N,d\rangle=I_{OV}$. This means that the input instance to OV will contain $N=2^{n/k}$ vectors of dimension $d=m$.

This procedure is summarized in the first row of the following table, as well as other indicative reductions, in the same context. For a more detailed analysis of each reduction see the full version.

Consistency with fine grained complexity

While our framework encapsulates many natural structural properties, there are problems that are fine-grained reducible to each other and either do not have an obvious correlation between their structures, or have connections that are not apparent. We will show here that our definition for Parameterized Fine-Grained Reduction is consistent with those cases, as the set of problems that are reducible to each other via fine grained reductions (denoted as $S_{1}$) and the respective set for Parameterized Fine Grained Reductions (denoted as $S_{2}$) are equivalent.

Theorem 3.4**.**

*Let $S_{1}:=\{(A,B):A\leq_{FG}B\}$ and $S_{2}:=\{(A,B):A\leq_{PFG}B\}.$

Then $S_{1}=S_{2}$.*

• •

$S_{2}\subseteq S_{1}$

Firstly, given problems $A$ and $B$ with $a(n)$, $b(n)$ their respective conjectured best running times, if $\langle A\rangle\leq_{PFG}\langle B\rangle$, we can simply ignore the parameters involved in the reduction and treat it as a fine-grained reduction between A and B, as the time restrictions enforced in both definitions are identical ($a^{1-\delta}(n)$ bound for the reduction time, and $\sum_{i=1}^{q}b^{1-\varepsilon}(n_{i})$ for the calls to problem $B$).

• •

$S_{1}\subseteq S_{2}$

Lemma 3.5**.**

Given problems $A$ and $B$ with $a(n)$, $b(n)$ their respective conjectured best running times, if $A\leq_{FGR}B$, for every $\lambda_{i}$ in a given parameterization $\langle B\rangle$, for each query call $q_{j}$ made in the reduction, there exists a computable function $g_{j,i}:\mathbb{N}^{i_{A}}\longrightarrow\mathbb{N}$ such that $\lambda_{i}\leq g_{j,i}(k_{1},\ldots,k_{i_{A}})$, and as such $\langle A\rangle\leq_{PFG}\langle B\rangle$.

Proof 3.6**.**

We remind the reader here that for $\lambda_{i}$ to be considered a parameter of a problem $A$, it has to be the output of a computable function on the input of $A$. Hence, every parameter of $B$ has a computable function $f_{i}(I_{B})$ associated with it. Now, since the reduction producing the instances of $B$ is $a^{1-\delta}$-time computable, it can trivially be viewed as a computable function $F$ having as domain field the inputs to problem $A$, and range the input instances of $B$ it produces. Having these, we can simply take the composition of $F$ and each $f_{i}$ to produce computable functions $f^{\prime}_{i}=F\circ f_{i}$ that produce the aforementioned parameters of $B$. Hence, these parameters can be viewed both as parameters of $B$ and parameters of $A$. For these reasons, the fine-grained reduction can be viewed as $\langle A,k_{1},\dots\rangle\leq_{PFG}\langle B,\lambda_{1},\dots\rangle$ for $k_{i}=\lambda_{i}$ (ergo having the identity function as $g_{j,i}$).

4 Fixed Parameter Improvable Problems (FPI)

In this section we define a class of problems that admit parameterized improvements on their conjectured best running times, prove that this class is closed under PFGR, as well as produce new parameterized improvements as an application of this closure.

Definition 4.1** (FPI).**

Let $A$ be a problem with conjectured best running time $a(n)$. Then, $\langle A\rangle$ has the FPI property with respect to a set of parameters $K=(k_{1},k_{2},\ldots,k_{x})\subseteq\langle A\rangle$ 333in this context, $K\subseteq\langle A\rangle$ denotes a set of parameterization functions over the input of $A$. (denoted FPI$(A,K)$) if there exists an algorithm solving $\langle A\rangle$ in $O\left(a^{1-\varepsilon}(n)\cdot f(k_{1},k_{2},\ldots,k_{x})\right)$ time, for some $\varepsilon>0$ and a computable function $f$.

Remark 4.2**.**

For simplicity, in the case of a single parameter, we denote as $FPI(A,k)$ the property $FPI(A,\{k\})$.

Theorem 4.3**.**

For every NP-hard problem $A$ that admits an FPT algorithm w.r.t.  a parameter $k$, we have that $FPI(A,k)$, unless $P=NP$.

Proof 4.4**.**

Since all NP-hard problems are conjectured to demand exponential running time, any FPT algorithm that solves them in $O\left(n^{c}\cdot f(k)\right)$ time for some parameter $k$ can be viewed as an improvement to $O(a^{1-\varepsilon}(n)\cdot f(k))$; the actual improvement in the conjectured running time $a(n)$ is in fact much greater than $a^{\varepsilon}(n)$ .

Corollary 4.5**.**

The following problems, parameterized with the respective parameter are FPI:

• •

$\langle$* Vertex Cover, Solution size $\rangle$*

• •

$\langle$* SAT, Number of clauses $\rangle$*

• •

$\langle$* k-knapsack,k $\rangle$*

Definition 4.6** (Minimum Necessary Set).**

Let $\langle A,k_{1},\dots,k_{i_{A}}\rangle$, $\langle B,\lambda_{1},\dots,\lambda_{i_{B}}\rangle$ be parameterized problems such that $\langle A,k_{1},\dots,k_{i_{A}}\rangle\leq_{PFG}\langle B,\lambda_{1},\dots,\lambda_{i_{B}}\rangle$. We define as $K_{\Lambda}$ to be the minimum necessary set needed to bound the set of parameters $\Lambda$ of $\langle B\rangle$ with respect to g, ergo the parameter set ${k_{1},\ldots,k_{x}}$ of problem A for which $\exists\lambda_{i}\in\Lambda,\forall j\in[q]$ such that $g_{j,i}(k_{1},\dots,k_{A})\leq h(k_{1},\ldots,k_{x}),\leavevmode\nobreak\ k_{i}\in K_{\Lambda}$ for some computable function $h$.

Theorem 4.7** (Closure under PFGR).**

Let $\langle A,k_{1},\dots,k_{i_{A}}\rangle$, $\langle B,\lambda_{1},\dots,\lambda_{i_{B}}\rangle$ be parameterized problems. If $\langle A,k_{1},\dots,k_{i_{A}}\rangle\leq_{PFG}\langle B,\lambda_{1},\dots,\lambda_{i_{B}}\rangle$ and $FPI(B,\Lambda)$, then $FPI(A,K_{\Lambda})$, where $K_{\Lambda}$ is the minimum necessary set of $\Lambda$ w.r.t. $g$.

Proof 4.8**.**

It suffices to prove that there exists an algorithm for $A$ running in $O(a^{1-\varepsilon}(n)\cdot f(k_{1},\ldots,k_{x}))$ for $k_{i},\leavevmode\nobreak\ i\in[x]$, parameters of $\langle A\rangle$.

Since $\langle A\rangle\leq_{PFG}\langle B\rangle$, then for all $\varepsilon>0$ there exists a $\delta>0$ such that $I_{A}$ is evaluated by an $a^{1-\delta}(n)$ algorithm using $B$ as an oracle, and $\sum_{i=1}^{q}b^{1-\varepsilon}(n_{i})\leq a^{1-\delta}(n)$.

Also, $FPI(B,\Lambda)$, so there is an algorithm computing $B$ in $O(b^{1-\varepsilon^{\prime}}(n)\cdot f(\lambda_{1},\ldots,\lambda_{|\Lambda|}))$. We can use this algorithm to resolve the oracle calls in time $\sum_{i=1}^{q}b^{1-\varepsilon^{\prime}}(n_{i})f(\lambda_{1},\ldots,\lambda_{|\Lambda|})$.

We can use $K_{\Lambda}$ to describe the running time for B utilizing function h. As such, the total running time of $A$ is:

[TABLE]

[TABLE]

Hence, $FPI(A,K_{\Lambda})$.

The above result essentially means that any parametric improvement can be carried through a valid PFGR.

4.1 A subquadratic fixed-parameter algorithm for OV

We will now provide an analysis of a known reduction from $OV$ to $3/2$-approx-diameter [21] using the PFGR framework. Specifically, we show that since $3/2$-approx-diameter admits fixed parameter improvements [5] on the treewidth parameter (hence is in FPI), this can be used to provide a fixed-parameter improvement on the OV problem.

Theorem 4.9**.**

$\langle OV,dimension\rangle$* is PFG-reducible to $\langle 3/2$-approx-diameter$,treewidth\rangle$.*

Proof 4.10**.**

Note that this reduction is implemented using only one call, and we analyze only one parameter. As such, we will simplify the notation of $g_{j,i}$ to $g$.

We begin with the construction given in [21]: Given an $OV$ instance with sets $A$, $B$ as input, we create a graph as follows: for every $a\in A$ create a node $a\in G$, for every $b\in B$ create a node $b\in G$, and for every $i\in[d]$ create a node $c_{i}\in G$, as well as two nodes $x,y$. For every $a\in A$ and $i\in[d]$, if $a[i]=1$ we add the edge $(a,c_{i})$. Similarly, for every $b\in B$ and $i\in[d]$, if $b[i]=1$, we add the edge $(b,c_{i})$. Also, we add the edges $(x,a)$ for every $a\in A$, $(x,c_{i})$ for every $i\in[d]$, $(y,b)$ for every $b\in B$, $(y,c_{i})$ for every $i\in[d]$, and $(x,y)$.

It suffices to find which parameter is connected to treewidth via the reduction: As seen in 1-(a), the graph produced by the reduction has a very specific structure. That is, all nodes of group $A$ are linked exclusively with nodes of group $C$ and with node $x$. Similarly, for group $B$ we have connections to group $C$ and node $y$. Therefore, to produce a tree decomposition of $G$ we can leave the nodes of group $A$ unrelated with those of group $B$.

Now, the specific connections of nodes from the groups $A$, $B$ to the nodes of group $C$ can vary, depending on the form of the OV instance. We can however give an upper bound to the treewidth of $G$ as shown in 1-(b) by copying the whole group $C$ in all of the decomposition’s bags. One can check that each component induced by a label is connected, and that all edges of $G$ are covered by the given bags. This decomposition is of maximum bag size $d+2$ and hence of width $d+1$, where $d$ is the size of group $C$.

As follows from the definition, $d+1$ is an upper bound for the treewidth of $G$. However, another tree decomposition with smaller width could exist. In order to prove that the treewidth of $G$ is exactly $d+1$, we must show that there exist instances of OV that produce graphs through this reduction, corresponding to treewidth $d+1$. Depending on the vectors containing a 1 coordinate in the suitable position, we could end up with a graph containing as a minor a complete $K\{|A|=|B|,|C|\}$ bipartite graph. Since complete bipartite graphs $K_{m,n}$ have treewidth exactly $\min\{m,n\}$, we can deduce that all graphs $G$ produced by this reduction will have treewidth in the worst case $d+1$ (as seen in chapter 10 of [12]).

Since $d$ is exactly the dimension of the OV instance producing the graph, we can see that there exists a function $g$ that maps the dimension of the OV instance to the treewidth of the $3/2$- approx-dimension.

Therefore, the mapping is $g(\langle OV,d\rangle)=\langle 3/2$-approx-diameter $,treewidth-1\rangle$

It was shown in [5] that $3/2$-approx-diameter parameterized by treewidth has a subquadratic algorithm. Hence, FPI($3/2$-approx-diameter,treewidth). Now, as follows by theorem 4.7 we should expect that FPI(OV,k) where $g(k)=treewidth$. Equivalently, we would expect a parametric improvement to the running time of OV for the instances that are related to the ones of the 3/2-approx-Diameter problem of bounded treewidth.

By theorem 4.9 we have that since $3/2$-approx-diameter has a parameterized improvement for fixed treewidth, OV has a subquadratic algorithm for fixed dimension of the vectors.

We will construct a subquadratic fixed-parameter algorithm, via the process described above.

Specifically, for the reduction time: The graph constructed contained $2n+d+2$ nodes and $2nd+2d+2n$ edges, which can be constructed in $O(nd)$ time from the OV instance.

The resulting graph has $O(n+d)$ nodes, and the decision problem of $3/2$-approx-diameter for this graph also gives an answer for the decision problem of the OV instance.

The parameterized complexity of the algorithm solving diameter is $k^{2}n\log^{k-1}n$, where $k$ denotes the treewidth of the graph [5].

Ergo, since $k=d+1$ (via our reduction) we can use the above to obtain an algorithm for OV running in time:

[TABLE]

Remark 4.11**.**

Through our reduction, this result can be carried out to all problems PFG-reducible to OV, such as SAT or Hitting Set. See the full version for the respective analyses of these reductions.

Remark 4.12**.**

As we have seen, if problem $B$ admits parameterized improvements on parameters $\Lambda$, then through the reduction this can be translated to improvements on problem $A$ and parameters $K_{\Lambda}$ such that $\lambda_{i}\leq g(k_{1},...,k_{|K_{\Lambda}|})$, for $i\in[|\Lambda|]$. However, whether we can locate which parameters constitute $K_{\Lambda}$ or not depends on the invertibility of $g$. In the case $g$ is not invertible one can only show the existence of such an algorithm, but not necessarily construct it. Nevertheless, the FPI property still holds through our definition, because we can abuse the notation to interpret each $\lambda_{i}$ as a parameter of A, as it is a byproduct of the reduction which is an ($a(n)$-time) computable function on the input of $A$.

5 Circuit Characterization of FPI

We provide a characterization for FPI using circuit complexity. Specifically, it is known that any circuit of size $S(n)$ can be simulated by an algorithm with complexity $O(S(n))$, thus if one can design a circuit with size smaller than the conjectured complexity of the problem, then this can be translated into a faster algorithm.

As such, having a circuit of size $S(n)$, if we can fix any number of parameters $x$ such that the circuit can be seen as having $S^{\prime}(n)\leq a(n)^{1-\varepsilon}f(k_{1},\ldots,k_{x})$ size, we can use this circuit to produce a truly sub-$a(n)$ algorithm for our problem.

Nevertheless, the smallest circuit solving the problem may differ from the one produced via a simulation of an algorithm444which is the only universal way to produce a circuit from an arbitrary algorithm.. This means that an improvement in the size complexity of the circuit may not be enough to be translated into a more effective algorithm via an inverse simulation. In that case, for the improvement in the size of the circuit to be translated to a faster algorithm, it is necessary to exceed this difference. From now on, when referring to a circuit solving a problem, the reader should consider the one produced by the simulation procedure.

As shown in [14], we can simulate any algorithm running in time $a(n)$ by a circuit of size $S(n)=a(n)log(a(n))$. Thus, we can use this as an upper bound on the overall size complexity of the circuit produced, to show that an improvement in the size of the circuit $S^{1-\varepsilon}(n)f(k_{1},\ldots,k_{x})$ (for some $x$) is always sufficient.

Theorem 5.1**.**

Let $A$ be a problem with $a(n)$ conjectured best running time. Then, $FPI(A,K)$ if and only if for the uniform circuit family $\{C_{n}\}$ of size $S(n)$ computing $A$, for each $n\in\mathbb{N}$, $C_{n}$ has size $S^{\prime}(n)=S^{1-\varepsilon}(n)\cdot f(k_{1},\ldots,k_{|K|})$, for a computable function $f$.

Proof 5.2**.**

“$\Rightarrow$”:

[TABLE]

If we choose $0<\delta<\varepsilon$, then $a^{1-\varepsilon+\delta}(n)f(k_{1},\ldots,k_{|K|})=a^{1-\varepsilon^{\prime}}(n)f(k_{1},\ldots,k_{|K|})$ for $\varepsilon^{\prime}=\varepsilon-\delta$, which is an FPI improvement on the running time of the algorithm, since we can simulate the circuit of size $S^{\prime}(n)$ in linear time.

“$\Leftarrow$”:

if there is an algorithm and a parameter set $K$ for which the running time is $a^{1-\varepsilon}(n)f(k_{1},\ldots,k_{|K|})$, then we can simulate it with a circuit of size:

[TABLE]

Remark 5.3**.**

In the scope of parameterized complexity, we can transform the addition in the second line into multiplication, since it is equivalent, as seen in [12].

If we choose $0<\delta<\varepsilon$, then $S^{\prime}(n)=a^{1-\varepsilon+\delta}(n)f^{\prime}(k_{1},\ldots,k_{|K|})=a^{1-\varepsilon^{\prime}}(n)f^{\prime}(k_{1},\ldots,k_{|K|})\leq S^{1-\varepsilon^{\prime}}(n)f^{\prime}(k_{1},\ldots,k_{|K|})$, for $\varepsilon^{\prime}=\varepsilon-\delta$.

6 Conclusion

In this work we have introduced a framework for fine-grained reductions that can capture a deeper connection between the problems involved, namely, a correlation among their parameters. We have shown that this framework captures the essence of the fine-grained approach without restricting the results. As a byproduct of our analysis, we defined and studied the structure of improvable problems, and the implications of fine-grained reductions on such problems. Finally, we produced a fixed parameter improvement in the running time of the OV problem by utilizing its parametric correlation to the $3/2$-approx-diameter problem.

A notable discussion in this field, is whether or not this framework can be used to define a complexity class, since FPI as a property has some unusual features. Specifically, the inherent meaning of "hardness" that arises, results in the absence of maximal elements (at least currently) in the partial ordering defined by parameterized fine-grained reductions. Additionally, because of the conjectured nature of our notion of improvements, the property $FPI(A,K)$ is directly related to previous work on each problem. It is possible that a parameterized algorithm may be proven sub-optimal in the case a problem’s conjectured best running time is updated, resulting in disproving said property. As such, if problems having this property are considered a class, inclusion in this class could be negated after the fact, which is inconsistent with traditional complexity classes.

Using this framework, one can follow the direction of Theorem 4.9 to produce parameterized improvements via the transitivity of PFGR. This analysis can be done for each reduction in the fine-grained reduction web, producing a wide variety of improved algorithms on many interesting problems.

A natural question to consider is the relation between our work and traditional parameterized approach. As seen in Theorem 4.3, it remains an open problem to find the exact relation between FPI and FPT, that is, to formally characterize the problems in FPT that are not FPI. Additionally, one could potentially utilize the plethora of results available through the framework on parameter tractable or harder problems. All of these results may be translated to our terminology given the appropriate assumptions.