arXiv subjects

Krišjānis Prūsis

Publications and source records attributed to Krišjānis Prūsis.

15 recordsLinked to original sources

arXiv2026

Certification complexity of Boolean functions

Certificate complexity $(C(f ))$ is a fundamental measure of complexity of Boolean functions f which counts the number of bits of an input that need to be known in order for the value of the function to be determined. A certificate can be viewed as a partial assignment, or a boolean subcube where the function is constant. Certificate complexity is well understood for deterministic query (or decision tree) complexity $(D)$ and other query models such as bounded-error randomized and quantum complexity $(R, Q)$, but not as well for quantum zero-error $(Q_0)$ and exact query complexity $(Q_E)$, where there is no agreed-upon certificate 'object' (even for $Q$). Instead, we study an operational notion of certification and apply it to various query-based models, with a focus on zero-error and exact quantum query complexity, but also on polynomial degree measures. We give new characterizations of $C, RC$ (randomized certificate complexity) and $QC$ (quantum certificate complexity), in terms of various measures such as classical and quantum sabotage complexity, unambiguous certificate complexity, and variants of polynomial degree. Certification complexity also gives rise to new lower bounds on $Q_E$ and $Q_0$, the quantum analogues of $D$ and $R_0$, complexity measures for which few lower bound techniques are known which are not already lower bounds for two-sided error quantum query complexity. We exhibit a total Boolean function for which our certification complexity measure gives a tight lower bound for $Q_0$, but rational degree and $Q$ are asymptotically smaller.

cs.CC↗

arXiv2025

Boolean Functions with Minimal Spectral Sensitivity

We show examples of total Boolean functions that depend on $n$ variables and have spectral sensitivity $Θ(\sqrt{\log n})$, which is asymptotically minimal. Our main new function combines the Hamming code with the Boolean address function and has $λ(f) = \sqrt{(1+o(1)) \log_2 n}$, which is optimal even up to a constant factor. By combining this function with itself in a specific way, we also obtain a family of functions with $\text{s}_0(f) = (c+o(1)) \log_2 n$ and $\text{s}_0(f) = (1-c+o(1)) \log_2 n$ for any $c \in [0,1]$. This is an optimal tradeoff for Boolean functions with low sensitivity, as the lower bound on sensitivity by Simon generalizes to \[\text{s}_0(f)+\text{s}_1(f)\geq\log_2 n - \log_2 \log_2 n + 2.\] As a corollary, this gives a new example of a function with minimal possible sensitivity (up to a constant factor), $\text{s}(f) = (\frac{1}{2}+o(1)) \log_2 n$.

cs.CC↗

arXiv2022

Strong dispersion property for the quantum walk on the hypercube

We show that the discrete time quantum walk on the Boolean hypercube of dimension $n$ has a strong dispersion property: if the walk is started in one vertex, then the probability of the walker being at any particular vertex after $O(n)$ steps is of an order $O(1.4818^{-n})$. This improves over the known mixing results for this quantum walk which show that the probability distribution after $O(n)$ steps is close to uniform but do not show that the probability is small for every vertex. A rigorous proof of this result involves an intricate argument about analytic properties of Bessel functions.

quant-ph↗

arXiv2022

Quantum speedups for treewidth

In this paper, we study quantum algorithms for computing the exact value of the treewidth of a graph. Our algorithms are based on the classical algorithm by Fomin and Villanger (Combinatorica 32, 2012) that uses $O(2.616^n)$ time and polynomial space. We show three quantum algorithms with the following complexity, using QRAM in both exponential space algorithms: $\bullet$ $O(1.618^n)$ time and polynomial space; $\bullet$ $O(1.554^n)$ time and $O(1.452^n)$ space; $\bullet$ $O(1.538^n)$ time and space. In contrast, the fastest known classical algorithm for treewidth uses $O(1.755^n)$ time and space. The first two speed-ups are obtained in a fairly straightforward way. The first version uses additionally only Grover's search and provides a quadratic speedup. The second speedup is more time-efficient and uses both Grover's search and the quantum exponential dynamic programming by Ambainis et al. (SODA '19). The third version uses the specific properties of the classical algorithm and treewidth, with a modified version of the quantum dynamic programming on the hypercube. Lastly, as a small side result, we also give a new classical time-space tradeoff for computing treewidth in $O^*(2^n)$ time and $O^*(\sqrt{2^n})$ space.

quant-ph↗

arXiv2020

Quantum Lower and Upper Bounds for 2D-Grid and Dyck Language

We study the quantum query complexity of two problems. First, we consider the problem of determining if a sequence of parentheses is a properly balanced one (a Dyck word), with a depth of at most $k$. We call this the $Dyck_{k,n}$ problem. We prove a lower bound of $Ω(c^k \sqrt{n})$, showing that the complexity of this problem increases exponentially in $k$. Here $n$ is the length of the word. When $k$ is a constant, this is interesting as a representative example of star-free languages for which a surprising $\tilde{O}(\sqrt{n})$ query quantum algorithm was recently constructed by Aaronson et al. Their proof does not give rise to a general algorithm. When $k$ is not a constant, $Dyck_{k,n}$ is not context-free. We give an algorithm with $O\left(\sqrt{n}(\log{n})^{0.5k}\right)$ quantum queries for $Dyck_{k,n}$ for all $k$. This is better than the trival upper bound $n$ for $k=o\left(\frac{\log(n)}{\log\log n}\right)$. Second, we consider connectivity problems on grid graphs in 2 dimensions, if some of the edges of the grid may be missing. By embedding the "balanced parentheses" problem into the grid, we show a lower bound of $Ω(n^{1.5-ε})$ for the directed 2D grid and $Ω(n^{2-ε})$ for the undirected 2D grid. The directed problem is interesting as a black-box model for a class of classical dynamic programming strategies including the one that is usually used for the well-known edit distance problem. We also show a generalization of this result to more than 2 dimensions.

cs.DS↗

arXiv2019

Quantum Lower Bounds for 2D-Grid and Dyck Language

We show quantum lower bounds for two problems. First, we consider the problem of determining if a sequence of parentheses is a properly balanced one (a Dyck word), with a depth of at most $k$. It has been known that, for any $k$, $\tilde{O}(\sqrt{n})$ queries suffice, with a $\tilde{O}$ term depending on $k$. We prove a lower bound of $Ω(c^k \sqrt{n})$, showing that the complexity of this problem increases exponentially in $k$. This is interesting as a representative example of star-free languages for which a surprising $\tilde{O}(\sqrt{n})$ query quantum algorithm was recently constructed by Aaronson et al. Second, we consider connectivity problems on directed/undirected grid in 2 dimensions, if some of the edges of the grid may be missing. By embedding the "balanced parentheses" problem into the grid, we show a lower bound of $Ω(n^{1.5-ε})$ for the directed 2D grid and $Ω(n^{2-ε})$ for the undirected 2D grid. The directed problem is interesting as a black-box model for a class of classical dynamic programming strategies including the one that is usually used for the well-known edit distance problem. We also show a generalization of this result to more than 2 dimensions.

quant-ph↗

arXiv2018

All Classical Adversary Methods are Equivalent for Total Functions

We show that all known classical adversary lower bounds on randomized query complexity are equivalent for total functions, and are equal to the fractional block sensitivity $\text{fbs}(f)$. That includes the Kolmogorov complexity bound of Laplante and Magniez and the earlier relational adversary bound of Aaronson. This equivalence also implies that for total functions, the relational adversary is equivalent to a simpler lower bound, which we call rank-1 relational adversary. For partial functions, we show unbounded separations between $\text{fbs}(f)$ and other adversary bounds, as well as between the adversary bounds themselves. We also show that, for partial functions, fractional block sensitivity cannot give lower bounds larger than $\sqrt{n \cdot \text{bs}(f)}$, where $n$ is the number of variables and $\text{bs}(f)$ is the block sensitivity. Then we exhibit a partial function $f$ that matches this upper bound, $\text{fbs}(f) = Ω(\sqrt{n \cdot \text{bs}(f)})$.

cs.CC↗

arXiv2018

On Block Sensitivity and Fractional Block Sensitivity

We investigate the relation between the block sensitivity $\text{bs}(f)$ and fractional block sensitivity $\text{fbs}(f)$ complexity measures of Boolean functions. While it is known that $\text{fbs}(f) = O(\text{bs}(f)^2)$, the best known separation achieves $\text{fbs}(f) = \left(\frac{1}{3\sqrt2} +o(1)\right) \text{bs(f)}^{3/2}$. We improve the constant factor and show a family of functions that give $\text{fbs}(f) = \left(\frac{1}{\sqrt6}-o(1)\right) \text{bs}(f)^{3/2}.$

cs.CC↗

arXiv2018

Quantum Speedups for Exponential-Time Dynamic Programming Algorithms

In this paper we study quantum algorithms for NP-complete problems whose best classical algorithm is an exponential time application of dynamic programming. We introduce the path in the hypercube problem that models many of these dynamic programming algorithms. In this problem we are asked whether there is a path from $0^n$ to $1^n$ in a given subgraph of the Boolean hypercube, where the edges are all directed from smaller to larger Hamming weight. We give a quantum algorithm that solves path in the hypercube in time $O^*(1.817^n)$. The technique combines Grover's search with computing a partial dynamic programming table. We use this approach to solve a variety of vertex ordering problems on graphs in the same time $O^*(1.817^n)$, and graph bandwidth in time $O^*(2.946^n)$. Then we use similar ideas to solve the travelling salesman problem and minimum set cover in time $O^*(1.728^n)$.

quant-ph↗

arXiv2017

Exact Affine Counter Automata

We introduce an affine generalization of counter automata, and analyze their ability as well as affine finite automata. Our contributions are as follows. We show that there is a language that can be recognized by exact realtime affine counter automata but by neither 1-way deterministic pushdown automata nor realtime deterministic k-counter automata. We also show that a certain promise problem, which is conjectured not to be solved by two-way quantum finite automata in polynomial time, can be solved by Las Vegas affine finite automata. Lastly, we show that how a counter helps for affine finite automata by showing that the language MANYTWINS, which is conjectured not to be recognized by affine, quantum or classical finite state models in polynomial time, can be recognized by affine counter automata with one-sided bounded-error in realtime.

cs.FL↗

arXiv2016

Oscillatory Localization of Quantum Walks Analyzed by Classical Electric Circuits

We examine an unexplored quantum phenomenon we call oscillatory localization, where a discrete-time quantum walk with Grover's diffusion coin jumps back and forth between two vertices. We then connect it to the power dissipation of a related electric network. Namely, we show that there are only two kinds of oscillating states, called uniform states and flip states, and that the projection of an arbitrary state onto a flip state is bounded by the power dissipation of an electric circuit. By applying this framework to states along a single edge of a graph, we show that low effective resistance implies oscillatory localization of the quantum walk. This reveals that oscillatory localization occurs on a large variety of regular graphs, including edge-transitive, expander, and high degree graphs. As a corollary, high edge-connectivity also implies localization of these states, since it is closely related to electric resistance.

quant-ph↗

arXiv2016

Doubling the Success of Quantum Walk Search Using Internal-State Measurements

In typical discrete-time quantum walk algorithms, one measures the position of the walker while ignoring its internal spin/coin state. Rather than neglecting the information in this internal state, we show that additionally measuring it doubles the success probability of many quantum spatial search algorithms. For example, this allows Grover's unstructured search problem to be solved with certainty, rather than with probability 1/2 if only the walker's position is measured, so the additional measurement yields a search algorithm that is twice as fast as without it, on average. Thus the internal state of discrete-time quantum walks holds valuable information that can be utilized to improve algorithms. Furthermore, we determine conditions for which spatial search problems on regular graphs are amenable to this doubling of the success probability, and this involves diagrammatically analyzing search using degenerate perturbation theory and deriving a useful formula for how the quantum walk acts in its reduced subspace.

quant-ph↗

arXiv2016

Stationary States in Quantum Walk Search

When classically searching a database, having additional correct answers makes the search easier. For a discrete-time quantum walk searching a graph for a marked vertex, however, additional marked vertices can make the search harder by causing the system to approximately begin in a stationary state, so the system fails to evolve. In this paper, we completely characterize the stationary states, or 1-eigenvectors, of the quantum walk search operator for general graphs and configurations of marked vertices by decomposing their amplitudes into uniform and flip states. This infinitely expands the number of known stationary states and gives an optimization procedure to find the stationary state closest to the initial uniform state of the walk. We further prove theorems on the existence of stationary states, with them conditionally existing if the marked vertices form a bipartite connected component and always existing if non-bipartite. These results utilize the standard oracle in Grover's algorithm, but we show that a different type of oracle prevents stationary states from interfering with the search algorithm.

quant-ph↗

arXiv2015

Sensitivity versus Certificate Complexity of Boolean Functions

Sensitivity, block sensitivity and certificate complexity are basic complexity measures of Boolean functions. The famous sensitivity conjecture claims that sensitivity is polynomially related to block sensitivity. However, it has been notoriously hard to obtain even exponential bounds. Since block sensitivity is known to be polynomially related to certificate complexity, an equivalent of proving this conjecture would be showing that certificate complexity is polynomially related to sensitivity. Previously, it has been shown that $bs(f) \leq C(f) \leq 2^{s(f)-1} s(f) - (s(f)-1)$. In this work, we give a better upper bound of $bs(f) \leq C(f) \leq \max\left(2^{s(f)-1}\left(s(f)-\frac 1 3\right), s(f)\right)$ using a recent theorem limiting the structure of function graphs. We also examine relations between these measures for functions with small 1-sensitivity $s_1(f)$ and arbitrary 0-sensitivity $s_0(f)$.

cs.CC↗

arXiv2014

A Tight Lower Bound on Certificate Complexity in Terms of Block Sensitivity and Sensitivity

Sensitivity, certificate complexity and block sensitivity are widely used Boolean function complexity measures. A longstanding open problem, proposed by Nisan and Szegedy, is whether sensitivity and block sensitivity are polynomially related. Motivated by the constructions of functions which achieve the largest known separations, we study the relation between 1-certificate complexity and 0-sensitivity and 0-block sensitivity. Previously the best known lower bound was $C_1(f)\geq \frac{bs_0(f)}{2 s_0(f)}$, achieved by Kenyon and Kutin. We improve this to $C_1(f)\geq \frac{3 bs_0(f)}{2 s_0(f)}$. While this improvement is only by a constant factor, this is quite important, as it precludes achieving a superquadratic separation between $bs(f)$ and $s(f)$ by iterating functions which reach this bound. In addition, this bound is tight, as it matches the construction of Ambainis and Sun up to an additive constant.

cs.CC↗