Generalized Quantum Deutsch-Jozsa Algorithm

Abstract

Quantum computing aims to provide algorithms and hardware that allows for solving computational problems asymptotically faster than on classical computers. Yet, design of new, fast quantum algorithms is not straightforward, and the field faces high barriers of entry for traditional computer scientists. One of the main didactic examples used to introduce speedup resulting from quantum computing is the Deutsch-Jozsa algorithm for discriminating between constant and balanced functions. Here, we show a generalization of the Deutsch-Jozsa algorithm beyond balanced functions that can be used to further illustrate the design choices underpinning quantum algorithms.

Introduction

Quantum computing studies algorithms and hardware for performing computation using systems that exploit quantum physics. In the gate model of quantum computing [6], the information storage and processing are done using tools from linear algebra. The information is stored in a quantum register composed of quantum bits. Each quantum bit is represented as a unit-norm vector in a two-dimensional complex Hilbert space. A multi-qubit register is modeled as a tensor product space arising from the individual quantum bits. The information in the quantum register can evolve in time according to invertible, inner product-preserving transformations, modeled mathematically in the gate model of quantum computing as unitary operators. The information in the quantum register can be accessed, to some extent, through quantum measurement, typically modeled as a randomized projection on vectors from the computational basis of the Hilbert space.

The key promise of quantum computing is to achieve speedup compared to classical computers [10], leading to faster algorithms in many domains, including linear algebra [5], database search [4], or machine learning [1, 3, 9]. The study of quantum algorithms can also lead to more efficient classical methods [7, 11].

One of the first, didactic example of a problem for which a quantum computer abstracted using the gate model shows speedup is a promise problem known as the Deutsch-Jozsa problem [2]. Assume that you are given a Boolean function on n-bits: with a black-box access. That is, on a classical computer, you can call it on any bit string and see the result, but you cannot decompile it. On a quantum computer, you have access to an oracle, a unitary transformation that performs the function using some form of input and output encoding.

In the Deutsch-Jozsa problem, we are promised that the function is of one of two types

• constant, that is, always returns 0, or always returns 1,

• balanced, that is, for half of the possible inputs it returns 0, for the remaining inputs, it returns 1.

The task is to use the ability to execute f(x) for any x to figure out if f is constant, or balanced.

Let be the number of distinct inputs x. On a classical computer, we need at least two calls to f to be able to decide if the function is constant or balanced – in the most optimistic scenario when first call returns 0 and the second returns 1, we know the answer after these two calls to f. But if we see zeros all the time, we need calls to have the answer – if value number is also 0, it is a constant function, if the value is 1, it is a balanced function. Thus, pessimistically, we need calls to f to solve the Deutsch-Jozsa problem on a classical computer. It is well-known that on a quantum computer, we can solve the Deutsch-Jozsa problem much quicker, using just one call to the unitary oracle .

The Deutsch-Jozsa algorithm has been recently generalized to include discrimination between balanced functions and almost-constant functions [8], with the query complexity increasing with the distance from a constant function. Here, we show that it can be generalized in a different way, to a family of promise problems involving discrimination between a specific constant function , for example an all-zero function, and a family of functions that have fixed level of imbalance, that is, have exactly k outputs equal to one, as long as . We show that this problem can be solved with only one query to the function oracle.

Quantum Deutsch-Jozsa Algorithm

To define the Deutsch-Jozsa algorithm, we need to have ability to evaluate Boolean functions using unitary operators, and the ability to use Boolean function evaluation to provide the answer whether the function is constant or balanced.

Quantum Boolean Function Evaluation

A Boolean function on n bits returning an m bit string is a function . Consider , and a function that negates all bits of x. It is a permutation - a one-to-one mapping - on the set . Now consider a function XOR , where is a modulo-two addition. If a bit in y is 0, the corresponding bit in x is not changed – an identity mapping, a particular form of permutation, on those bits. If a bit in y is 1, the corresponding bit in x is negated - a permutation on those bits. That is, for arbitrary n-bit y, is a permutation on the set - vectors for all possible x are mutually orthogonal, same as are. Then, a linear mapping will produce when we perform . Since is a permutation on , it is a one-to-one mapping. It also preserves the inner product. The inner product among basis vectors , is null, and the inner products among the outputs are also null. This mapping is inner-product-preserving, and thus compatible with the rules of quantum mechanics.

Not all functions are permutations; a constant function that always returns all bits set to 0 is not a permutation. Consider an arbitrary function . Let us have an -qubit system . Consider a state , where is one of the basis states of , and is one of the basis states of . We wish to have a linear transformation , a unitary operator, that takes the vector, and produces, on output, a state , in particular, for , it produces . For each x, is a permutation on the basis states of , and thus is a permutation on the basis states of . Hence,

which performs , is a one-to-one mapping that preserves the inner product – and thus can describe unitary evolution of a quantum system.

Consider , arbitrary n, and an -qubit system in an arbitrary state of the form . Let be a Pauli X gate followed by Hadamard gate; it transforms to and to , and is Hermitian. Let denote application of E to the last, qubit. We have

We obtained the result by seeing that differs by a sign depending on the value of f(x); if , it is , if it is . Then we used phase kickback to the top qubits. Value of is reflected in change of phase of by , whereas results in no change.

We now see two ways of representing the result of applying f(x) as encoded by :

The first option is to encode the result in the state of the last qubit, the second is to encode it in the phase of the input qubits.

The Deutsch-Jozsa Problem

Consider four query states for arbitrary binary u, v. Two are simple, and , and correspond to two possible one-bit constant functions. Two other are entangled, and , and correspond to the two one-bit balanced functions.

If someone prepares a two-qubit system in one of the four query states, can we distinguish whether it is any of these two and , or any of these two and ? We have , that is, it is easy to distinguish from , and from . All other inner products of these four states are equal to . Any unitary transformation has to preserve the dimensionality of the space, and the inner products. Thus, there is no mapping that would map to be orthogonal to or ; same for . If we want to use orthogonality of any member from one group of states to any member from the other group of states to reliably distinguish states from one group from the other, then a group composed of and cannot be reliably distinguished from group consisting of and .

We have seen above two ways of representing the result of applying a binary function f(x) given a state : encoding the result as an additional qubit, or as a phase change of the input qubit. Consider a n-bit binary function f. We can construct a state using Hadamard transform. Then, we can construct a state , and apply our two options of evaluating f quantum mechanically to this -qubit state. We will get

These two options are not equivalent. The four query states we have seen above can be seen as the first option for if we equate and ; indeed . We have seen that we cannot use this representation to decide, based on orthogonality, if we got a function that is constant, or that returns equal number of 0’s and 1’s.

On the other hand, consider the second representation, or actually just its first qubit . A constant function will have , while a balanced function will have . We can ignore the global phase, that is, the sign, and we end up with two orthogonal states, for constant and for balanced function. As we can see, while unitary actions after applying the black-box unitary oracle cannot change the distinguishability of states because they must preserve the inner products, differences prior to applying the function oracle can affect our ability to distinguish states.

Generalized Deutsch-Jozsa Problem

We show here that the ability to distinguish all-zeros from all-ones that we get from and the ability to distinguish all-zeros and all-ones from a balanced function that we get from are not the only possibilities for quickly solving promise problems involving two groups of binary functions. We can form a class of single-qubit unitary operators A defined by the condition ,

and observe that unitaries I and E are at the extreme ends of the family, with a spectrum of other operators in between. These operators can each solve a different promise problem of discriminating between two classes of functions.

Consider two functions and with the corresponding black-box unitaries and , and let and . Also, let if and otherwise, and ; we will use to denote the number of outputs on which the functions agree, and to denote the Hamming distance between the outputs, that is, the number of outputs that differ; we have .

Let denote application of A to the last, -st qubit of an -qubit system. Then, we have

and a similar expression for , with replaced by .

The inner product of the two states is

where . Indeed, we have

The last equality comes from the fact that if and only if , and if and only if .

To achieve perfect distinguishability of the resulting states through quantum measurement, which corresponds to having inner product , we need to set a, b such that becomes . Since for any two unit-norm quantum states, we can do that as long as ; the promised functions and must differ on at least half of their outputs to be perfectly distinguishable through orthogonality of the results of and .

For any , we can perfectly distinguish functions with exactly k outputs of 1 from the all-zero constant function using just one oracle access by using unitary defined by ; note that here . On a classical computer, the same task can be achieved quickly if , but can take function calls if k is close to .

As an example, consider a problem involving functions defined over bits. Let be an all-zero function, that is, for any of the 16 possible input bitstrings, it returns null. Let be an imbalanced function with exactly out of 16 inputs returning one, and with four null outputs. To discriminate from any possible , we need to find a, b such that and : we can have and .

In contrast to applying A prior to to help solve the problem of discriminating an all-zero function and a function with k ones and zeros on outputs, we can consider the result of applying or instead. For , we arrive at the state for the all-zero , while for we arrive at , which has inner product . Only the all-one function is distinguishable from the all-zero function . Using instead leads to for and to for . These have inner product of . Here, only setting , that is, using a balanced function as in the original Deutsch-Jozsa problem, leads to the ability to distinguish from without error using a single measurement.

With minor changes, we can also, for any , distinguish a function with k zero outputs from an all-one constant function. The original Deutsch-Jozsa choice of is the only case when we can distinguish from both all-zero and all-one functions .

Conclusion

The Deutsch-Jozsa problem is often used to illustrate basic concepts in the gate model of quantum computing. Here, we show that the balance-vs-constant function promise problem lies at the edge of a family of promise problems involving discriminating between two subclasses of Boolean functions. The analysis of this broader family of problems can provide improved understanding of the conditions that lead to quantum speedup in Deutsch-Jozsa algorithm.