A Quantum Algorithm for the Classification of Patterns of Boolean Functions

Abstract

This paper introduces a novel quantum algorithm that is able to classify a hierarchy of classes of imbalanced Boolean functions. The fundamental characteristic of imbalanced Boolean functions is that the proportion of elements in their domain that take the value 0 is not equal to the proportion of elements that take the value 1. For every positive integer, n, the hierarchy contains a class of n-ary Boolean functions defined according to their behavioral pattern. The common trait of all the functions belonging to the same class is that they possess the same imbalance ratio. Our algorithm achieves classification in a straightforward manner as the final measurement reveals the unknown function with a probability of $1.0$. Let us also note that the proposed algorithm is an optimal oracular algorithm because it can classify the aforementioned functions with just a single query to the oracle. At the same time, we explain in detail the methodology we followed to design this algorithm in the hope that it will prove general and fruitful, given that it can be easily modified and extended to address other classes of imbalanced Boolean functions that exhibit different behavioral patterns.

1. Introduction

The endeavor to construct quantum computers that surpass the capabilities of classical computers poses a significant challenge in our era. It is important to acknowledge that this goal has not yet been realized. However, substantial progress is evident, as illustrated by IBM’s advancements with the 127-qubit Eagle [1], the 433-qubit Osprey [2], the 1121-qubit Condor [3], and the latest and most powerful R2 Heron [4]. These developments indicate a swift movement towards the practical application of quantum technology. All these suggest that quantum technology has reached a level of maturity that warrants careful consideration in the development and implementation of algorithms targeting difficult problems.

The imperative to enhance the scale of quantum computers represents the most significant obstacle to their potential application in industrial-scale problems. It has become evident that advancing quantum computers beyond the Noisy Intermediate-Scale Quantum (NISQ) level will necessitate scientific breakthroughs and the resolution of various technological hurdles. In our assessment, the most promising strategy to address the scaling dilemma currently lies in the advancement of distributed quantum computing systems. In the realm of classical computing, the concept of interlinking smaller processors to distribute computational tasks has emerged as a solution to scaling difficulties. This principle is believed to be equally relevant to quantum computing, where the scaling challenge encourages the exploration of connecting smaller quantum computers. A distributed quantum computing system would comprise a network of quantum nodes, each possessing a specific number of qubits for processing and the capability to transmit both classical and quantum information. Nevertheless, the inherent differences between quantum and classical computing introduce unique challenges, not present in classical networks, in the design of networked quantum computers. Fortunately, recently there have been significant technological advancements in hardware [5,6] and design concepts [7,8]. In fact, very recently, researchers demonstrated distributed quantum computing by employing a photonic network interface to effectively connect two distinct quantum processors, thus creating a unified and fully integrated quantum computer [9,10]. It is our firm belief that we are entering the era of distributed quantum computing.

In this work, we introduce a new quantum algorithm that classifies classes of Boolean functions that are characterized by specific patterns that exhibit imbalance. The fundamental characteristic of these imbalanced Boolean functions is that the proportion of elements in their domain that take the value 0 is not equal to the proportion of elements that take the value 1. We refer to this algorithm as the Boolean Function Pattern Quantum Classifier, or BFPQC for short.

Quantum classification of Boolean functions is important because it bridges theoretical quantum advantages, such as query complexity reductions, with practical applications in cryptography, quantum machine learning, and optimization. In cryptography, Boolean functions in block ciphers must satisfy properties like nonlinearity, balancedness, or correlation immunity. Quantum classification can accelerate the evaluation or optimization of such functions, aiding in cryptanalysis or designing secure systems. Quantum algorithms like the Deutsch–Jozsa algorithm demonstrate exponential speedup for certain Boolean function properties (e.g., determining if a function is constant or balanced). While this is a toy problem, it hints at quantum advantages for classification tasks involving Boolean functions with specific structures. Quantum kernel methods, such as those using Quantum Support Vector Machines (QSVMs), map Boolean inputs into high-dimensional quantum feature spaces via quantum circuits. This may reveal patterns in Boolean functions that are intractable classically, especially for functions with complex dependencies. In machine learning, many real-world datasets involve binary or categorical features. Quantum classification of Boolean functions can enhance classical machine learning models by exploiting quantum parallelism to process high-dimensional binary inputs more efficiently. Variational Quantum Classifiers use parameterized quantum circuits to learn Boolean functions. For example, a VQC can be trained to classify inputs based on a target Boolean function (e.g., parity, majority, or threshold functions), potentially requiring fewer parameters or shallower circuits than classical neural networks for certain tasks. While current hardware limitations (e.g., noise) restrict large-scale deployment, near-term systems excel in niche problems with structured data or specific function properties. As fault-tolerant quantum computers emerge, the ability to classify complex Boolean functions efficiently could revolutionize computational tasks.

We have drawn inspiration mainly from the many sophisticated works studying various extensions of the Deutsch–Jozsa algorithm. Already in [11], the authors examined a multidimensional version of the Deutsch–Jozsa problem. This was further expanded in [12] by considering evenly distributed and evenly balanced functions. Subsequently, in [13], the Deutsch–Jozsa algorithm was extended for balanced functions in finite Abelian subgroups. Another generalization appeared in [14]. Later, the researchers in [15] generalized the Deutsch–Jozsa problem and gave an optimal algorithm. A more recent clever generalization of the Deutsch–Jozsa algorithm can be found in [16]. Useful applications of the Deutsch–Jozsa algorithm were also obtained in [17,18]. Two particularly interesting works towards establishing a distributed version of the Deutsch–Jozsa algorithm were [19,20]. In a related development, the authors in [21] extended Deutsch’s algorithm for binary Boolean functions.

Important general results for query complexity in the oracle model were presented in [22], where a sophisticated upper bound for the number of Boolean functions that can be distinguished with k quantum queries was derived, and in [23], where two methods for proving lower bounds on quantum query complexity were studied. A noteworthy result was obtained in [24], where the problem of quantum learning from a noisy quantum example oracle was investigated, and it was shown that the class of parity functions can be learned in logarithmic time from corrupted quantum queries. We should also mention that oracular algorithms geared towards computing Boolean functions or achieving classification are often encountered in the literature on quantum learning and quantum machine learning. In [25], it was shown that the class of polynomial-size Disjunctive Normal Form expressions is efficiently learnable with respect to the uniform distribution by a quantum algorithm using a quantum example oracle. The authors in [26,27] demonstrated an important correlation between classical and quantum learning for both the models of exact learning and probably approximately correct learning from random examples. In [28], the authors introduce an advanced and sophisticated general technique for quantum concept learning. In a related work [29], the number of quantum queries required to identify an unknown multilinear polynomial of degree d in n variables over a finite field was established. The authors in [30] compared a quantum and a classical machine designed for learning Boolean functions in order to address how a quantum system improves the machine learning behavior, and concluded that the quantum machine has a wider acceptable region, induced by quantum superposition. The researchers in [31] presented quantum algorithms for performing nearest-neighbor classification and k-means clustering that promise significant reductions in their query complexity relative to their classical counterparts. Quantum oracles were shown to reduce the time required to train a deep restricted Boltzmann machine and provide a richer and more comprehensive framework for deep learning than classical computing in [32].

We present our algorithm in the form of game, called the Classification Game, that features the familiar characters of Alice and Bob. It is anticipated that the entertaining aspect of games will facilitate a better understanding of the technical concepts involved. Since their introduction in 1999 [33,34], quantum games have gained considerable popularity, as quantum strategies often outperform classical ones [35,36]. A notable illustration of this is the well-known Prisoners’ Dilemma [34], which serves as a prime example and is applicable to various other abstract quantum games [37]. Although quantum games are fun, they can be used to solve critical problems like Quantum Key Distribution, Quantum Secret Sharing, and Quantum Private Comparison (see [38,39]). It is worth noting that many classical systems can be turned into quantum versions, including political frameworks, as demonstrated in recent studies [40].

Contribution. In this paragraph we present what we believe to be the main novelties introduced in this work.

• Numerous sophisticated studies have been published in the literature that employ quantum oracles to classify Boolean functions, such as those that expand upon the Deutsch–Jozsa algorithm. The vast majority of them explore balanced Boolean functions. However, as far as we are aware, there has been no previous research dedicated to imbalanced Boolean functions, which are characterized by an unequal number of elements in their domain that yield the values 0 and 1. This article introduces a novel quantum algorithm designed to classify a specific hierarchy of imbalanced Boolean function classes. For each positive integer, n, this hierarchy includes a class of Boolean functions, which are defined according to their behavioral characteristics. A defining feature of all functions within the same class is their shared imbalance ratio.
• Our algorithm achieves classification in a straightforward manner, as the final measurement determines the unknown function with a probability of $1.0$. A thorough complexity analysis of our algorithm is given in Section 5.1. This analysis proves that our algorithm is an optimal oracular algorithm, capable of conclusively classifying all Boolean functions belonging to the designating hierarchy with a probability of $1.0$ using just a single query to the oracle. At the same time, we show that our algorithm is superior to any deterministic classical algorithm for the same task.
• Of equal importance is the detailed explanation of the methodology followed in the development of this algorithm that we provide in Section 4. This is done with the expectation that it will prove both general and beneficial, as it can be readily adapted and expanded to tackle other classes of imbalanced Boolean functions that display varying behavioral patterns. The intuition of our methodology can be distilled in the phrase “from behavior to pattern vectors and then to unitary classifiers”. By appropriately modifying Definition 9 to include different pattern bases, one may construct unitary classifiers for these patterns, leading to new classification algorithms.

Organization

This article is structured in the following way. Section 1 introduces the topic and includes references to the relevant literature. Section 2 offers a brief overview of key concepts, which serves as a basis for grasping the technical details. Section 3 contains a comprehensive exposition to our algorithm, including a detailed small-scale example to build intuition. The general form of the algorithm is formally presented in Section 4. Finally, the paper wraps up with a summary and a discussion of the algorithm’s nuances in Section 5.

2. Notation and Terminology

2.1. Boolean Functions and Oracles

Let us first fix the notation and terminology we shall be using in the rest of this paper.

• $\mathbb{B}$ is the binary set $\{0,1\}$.
• A bit vector, $\mathbf{b}$, of length n is a sequence of n bits: $\mathbf{b}=b_{n-1}\dots b_0$. Two special bit vectors are the zero and the one bit vectors, denoted by $\mathbf{0}$ and $\mathbf{1}$, in which all the bits are zero and one, respectively: $\mathbf{0}=0\dots 0$ and $\mathbf{1}=1\dots 1$.
• To make clear, when we refer to the bit vector $\mathbf{b}\in {\mathbb{B}}^n$, we write $\mathbf{b}$ in boldface. Often, it is convenient to view $\mathbf{b}$ as the binary representation of the integer b.
• Each bit vector, $\mathbf{b}\in {\mathbb{B}}^n$, can also be viewed as the binary representation of one of the $2^n$ basis kets that form the computational basis of the $2^n$-dimensional Hilbert space.

Definition 1 

(Boolean function). A Boolean function, f, is a function from ${\mathbb{B}}^n$ to $\mathbb{B}$, $n\ge 1$.

Oracles are an important concept in quantum computing and play a crucial role in many quantum algorithms. An oracle is a black box that encodes a specific function or information into a quantum circuit, allowing quantum algorithms to solve problems more efficiently than classical algorithms in certain cases. It is used to evaluate the function or check a condition without revealing the internal details of how the function works. In quantum algorithms, oracles are often used to mark solutions to a problem or to provide information about a function’s behavior. For the purposes of our work, the following definition suffices.

Definition 2 

(Oracle and unitary transform). An oracle is a black box implementing a Boolean function, f. The idea here is that, being a black box function, we know nothing about its inner workings apart from the fact that it works correctly. Thus, it can be used for the construction of a unitary transform, $U_f$, that captures the behavior of f.

Henceforth, we shall assume that the corresponding unitary transform, $U_f$, implements the standard schema

$$U_f:|y\rangle |\mathbf{x}\rangle \to |y\oplus f(\mathbf{x})\rangle |\mathbf{x}\rangle .$$

(1)

In the literature, this type of oracle is sometimes referred to as a Deutsch–Jozsa oracle. We note in passing that there also other variations of oracles, such as the Grover oracle, which is typically used to mark solutions to a problem. In this work, every oracle and unitary transform is assumed to satisfy (1) and is used to deduce a function from its behavior. The standard measure of complexity in oracular algorithms is the query complexity, i.e., the number of queries to the oracle used by the algorithm.

For completeness, we recall the states |+〉 and |−〉, which are defined as

$$|+\rangle =H|0\rangle ={\displaystyle \frac{|0\rangle +|1\rangle }{\sqrt{2}}}$$

(2)

$$|-\rangle =H|1\rangle ={\displaystyle \frac{|0\rangle -|1\rangle }{\sqrt{2}}}$$

(3)

To obtain any useful information from schema (1), we set |y〉 equal to |−〉, in which case (1) takes the following familiar form:

$$\begin{array}{c}\hfill U_f:|-\rangle \mathbf{x}\to {(-1)}^{f\left(\mathbf{x}\right)}|-\rangle \mathbf{x}\rangle .\end{array}$$

(4)

Figure 1 and Figure 2 give a visual outline of the unitary transforms, $U_f$, that implement schemata (1) and (4), respectively. In all the quantum circuits used in this work, including those depicted in Figure 1 and Figure 2, the following conventions are used.

• The way of ordering the qubits adheres to the Qiskit [41] convention, i.e., the little-endian qubit indexing convention, where the least significant qubit is at the top of the figure and the most significant at the bottom.
• $IR$ is the quantum input register that contains n qubits.
• $OR$ is the single-qubit output register that is initialized to arbitrary state |y〉 in Figure 1 and to state |−〉 in Figure 2.
• $U_f$ is the unitary transform. Its precise mathematical expression depends on f and is hidden. However, it is taken for granted that is satisfies relation (1) in Figure 1 and relation (4) in Figure 2.

We mention that in the literature it is very common to use the word “promise” when referring to a particular property of the Boolean function f, meaning that we are guaranteed, or, if you prefer, we are certain with a probability of $1.0$ that f satisfies the property in question. A prominent such example comes from the Deutsch–Jozsa algorithm, where we are given the promise that f is either constant, or balanced.

Extending the operation of addition modulo 2 to bit vectors is a natural and fruitful generalization.

Definition 3 

(Bitwise addition modulo 2). Given two bit vectors, $\mathbf{x},\mathbf{y}\in {\mathbb{B}}^n$, with $\mathbf{x}=x_{n-1}\dots x_0$ and $\mathbf{y}=y_{n-1}\dots y_0$, we define their bitwise sum modulo 2, denoted by $\mathbf{x}\oplus \mathbf{y}$, as

$$\mathbf{x}\oplus \mathbf{y}(x_{n-1}\oplus y_{n-1})\dots (x_0\oplus y_0).$$

(5)

Following the standard approach, we use the same symbol, ⊕, to denote the operation of addition modulo 2 two between bits, and the bitwise sum modulo 2 between two bit vectors because the context always makes clear the intended operation.

2.2. A Brief Recap of the Deutsch–Jozsa Algorithm

In this subsection, we recall a few standard operations between bit vectors that will facilitate the forthcoming exposition, and give a brief reminder of the Deutsch–Jozsa algorithm.

Definition 4 

(Inner product modulo 2). The inner product modulo 2 is a function from ${\mathbb{B}}^n\times {\mathbb{B}}^n$ to $\mathbb{B}$ that takes as inputs two bit vectors, $\mathbf{x},\mathbf{y}\in {\mathbb{B}}^n$, and returns their inner product denoted by $\mathbf{x}•\mathbf{y}$. If $\mathbf{x}=x_{n-1}\dots x_0$ and $\mathbf{y}=y_{n-1}\dots y_0$, then $\mathbf{x}•\mathbf{y}$ is defined as

$$\mathbf{x}•\mathbf{y}:=x_{n-1}{y}_{n-1}\oplus \dots \oplus x_0{y}_0,$$

(6)

where := stands for “is defined as”, and ⊕ is addition modulo 2.

The fundamental relation that expresses the n-fold Hadamard transform of an arbitrary basis ket |$\mathbf{x}$〉 uses the inner product modulo 2. Its proof can be found in most standard textbooks, e.g., [42,43].

$$H^{\otimes n}|\mathbf{x}\rangle =2^{-{\displaystyle \frac{n}{2}}}\sum _{\mathbf{z}\in {\mathbb{B}}^n}{(-1)}^{\mathbf{z}•\mathbf{x}}|\mathbf{z}\rangle .$$

(7)

The Deutsch–Jozsa algorithm is a famous quantum algorithm that solves a specific problem faster than any classical algorithm. It determines whether the given Boolean function $f:{\mathbb{B}}^n\to \mathbb{B}$ is constant (produces the same output for all inputs) or balanced (outputs 0 for half the inputs and 1 for the other half) with a single function evaluation, compared with up to $2^{n-1}+1$ evaluations classically.

The algorithm takes as input an oracle for the unknown function, f. The oracle is of the Deutsch–Jozsa variation and the function f is promised to be either constant or balanced. The goal is to establish whether f is constant or balanced with a single oracle query. The abstract quantum circuit in Figure 3 visualizes the implementation of the Deutsch–Jozsa algorithm.

In the above Figure 3, the following notation is employed.

• $IR$ is the quantum input register that contains n qubits and starts its operation at state ${|0\rangle }^{\otimes n}$.
• $OR$ is the single-qubit output register initialized to state |1〉.
• H is the Hadamard transform.
• $U_f$ is the unitary transform corresponding to the oracle for the unknown function, f. The latter is promised to be constant or balanced.

Referring to Figure 3 and recalling that ordering the qubits adheres to the Qiskit [41] convention, we may express the initial state, $|{\psi }_0\rangle$, as shown below

$$\begin{array}{c}\hfill |{\psi }_0\rangle =|1\rangle |{0\rangle }^{\otimes n}.\end{array}$$

Applying Hadamard gates to all qubits leads to the next state, $|{\psi }_1\rangle$, which, by taking into into account (7) for $|\mathbf{x}\rangle$=${|0\rangle }^{\otimes n}$ and (3), can be written as

$$\begin{array}{c}\hfill |{\psi }_1\rangle =H|1\rangle H^{\otimes n}{|0\rangle }^{\otimes n}=\left({\displaystyle \frac{|0\rangle -|1\rangle }{\sqrt{2}}}\right)\left(2^{-{\displaystyle \frac{n}{2}}}\sum _{\mathbf{z}\in {\mathbb{B}}^n}|\mathbf{z}\rangle \right)=2^{-{\displaystyle \frac{n}{2}}}-\sum _{\mathbf{z}\in {\mathbb{B}}^n}|\mathbf{z}\rangle .\end{array}$$

The oracle’s action implementing schema (4) evolves the state to $|{\psi }_2\rangle$

$$\begin{array}{c}\hfill |{\psi }_2\rangle =2^{-{\displaystyle \frac{n}{2}}}|-\rangle \sum _{\mathbf{z}\in {\mathbb{B}}^n}{(-1)}^{f\left(\mathbf{z}\right)}|\mathbf{z}\rangle .\end{array}$$

Intuitively, this means that the oracle has encoded the output values of the Boolean function f, into the relative phase ${\sum }_{\mathbf{z}\in {\mathbb{B}}^n}{(-1)}^{f\left(\mathbf{z}\right)}$ of state $|{\psi }_2\rangle$. It is at this point exactly that we encounter the phase kickback phenomenon. Phase kickback is a fundamental trait of many quantum algorithms because an operation on the ancilla qubit induces a phase shift on the control qubits. In our case, the control qubits are the n qubits of the quantum input register, $IR$, and the ancilla qubit is the single-qubit output register, $OR$. To successfully employ this technique, it is necessary for the ancilla qubit to be in state ${\displaystyle \frac{|0\rangle -|1\rangle }{\sqrt{2}}}$=$H|1\rangle$=|−〉 (recall Equation (3)). Using phase kickback is crucial because the oracle instead of writing does $f\left(\mathbf{z}\right)$ explicitly to a qubit, and encodes it as a relative phase ${(-1)}^{f\left(\mathbf{z}\right)}$. This approach not only forfeits the need for additional storage qubits, but also allows the desired interference to happen cleanly. An obvious way to generate |−〉 is to initialize the ancilla qubit to state |1〉 and, subsequently, apply the Hadamard transform, H, as depicted in the quantum circuit of Figure 3. Modern-day quantum computers allow for the immediate initialization of qubits to states other than |0〉 and |1〉, such as |−〉. We have taken advantage of this capability by directly initializing to |−〉 the output register, $OR$, playing the role of the ancilla qubit, in all of the quantum classification circuits shown in the rest of this paper. The classification algorithm we present in this work also relies on the Deutsch–Jozsa oracle type and utilizes the phase kickback technique to encode the behavioral pattern of the unknown function, f, into the relative state of the quantum input register, $IR$.

Subsequently, by applying Hadamard gates to the n qubits of the quantum input register, $IR$, we drive the system into the $|{\psi }_3\rangle$ described below

$$\begin{array}{c}\hfill |{\psi }_3\rangle =2^{-n}-\sum _{\mathbf{w}\in {\mathbb{B}}^n}\sum _{\mathbf{z}\in {\mathbb{B}}^n}{(-1)}^{f\left(\mathbf{z}\right)\oplus \mathbf{w}•\mathbf{z}}|\mathbf{w}\rangle .\end{array}$$

(8)

Focusing on the amplitude of the basis state $\mathbf{w}$=${|0\rangle }^{\otimes n}$ within state $|{\psi }_3\rangle$, we see that it is given by the next equation

$$\begin{array}{c}\hfill 2^{-n}\sum _{\mathbf{z}\in {\mathbb{B}}^n}{(-1)}^{f\left(\mathbf{z}\right)},\end{array}$$

(9)

which enables us to distinguish between the following two antidiametrical cases.

(DJ₁)

If f is constant, then (7) reduces to $\pm 1.0$.

(DJ₂)

If f is balanced, then (7) reduces to $0.0$.

Thus, if we measure ${|0\rangle }^{\otimes n}$ we are absolutely certain that f is constant, whereas any other outcome means that f is balanced.

From a historical perspective, this algorithm was one of the first to show a clear quantum advantage, paving the way for more complex quantum algorithms like Shor’s and Grover’s. Its speedup is evident because the quantum algorithm uses 1 query vs. up to $2^{n-1}+1$ classically. Furthermore, it demonstrates quantum parallelism by evaluating f on all inputs simultaneously, and interference by amplifying desired outcomes.

3. The Basic Concepts Behind the BFPQC Algorithm

In this paper, we introduce a new quantum algorithm that differentiates and classifies a class of Boolean function that is characterized by a specific collection of patterns demonstrating imbalance. In view of its intended purpose, we call this algorithm the Boolean Function Pattern Quantum Classifier, or BFPQC for short. The current section gives the definitions regarding the main concepts, and presents a toy scale example illustrating its operation.

By giving rise to different elements of the computational basis with a probability of $1.0$. Our algorithm is an oracular algorithm because it relies on a oracle to achieve the classification. Its efficiency is demonstrated by the fact that it is optimal because it requires just one single query to complete its task.

Here we solve what is commonly referred to in the quantum literature as a promise problem, i.e., a problem where the input is promised to belong to a specific set. Promise algorithms are not required to work correctly on any input that does not satisfy the promise. Many quantum algorithms are designed to solve promise problems. For example, in the Deutsch–Jozsa algorithm, the promise is that the function is either constant or balanced. The Deutsch–Jozsa algorithm is designed to distinguish between these two cases efficiently, but it does not need to handle functions that are neither constant nor balanced. The same applies to our case: the BFPQC algorithm can correctly handle any function that belongs to a rigorously defined hierarchy, but it will not output the correct answer if this is not the case.

Our plan of action consists of the following successive steps.

(S₁)

We focus on imbalanced Boolean functions, i.e., those with the property that the number of elements in their domain that take the value 0 is not equal to the number of elements that take the value 1.

(S₂)

We employ the concept of pattern vectors to capture the behavior of imbalanced Boolean functions. For each positive integer $n\ge 1$, we define a set of $2^{2n}$ pattern vectors that all have an equal imbalance ratio, which is always $<{\displaystyle \frac{1}{2}}$.

(S₃)

Identifying an appropriate set of pattern vectors enables the construction of the corresponding unitary transform that accomplishes the classification.

Definition 5 

(Pattern vector). Given the Boolean function $f:{\mathbb{B}}^n\to \mathbb{B}$, $n\ge 1$, we define the concept of the unique pattern vector that encodes the behavior of f.

• The pattern vector $\mathbf{p}$=$p_{2^n-1}$…$p_1$$p_0$ of f is the element of ${\mathbb{B}}^{2^n}$, such that $p_i=f\left(\mathbf{i}\right)$, where $\mathbf{i}$ is the binary bit vector representing integer i, $0\le i\le 2^n-1$. In other words, the pattern vector, $\mathbf{p}$, lists the binary values of $f\left(\mathbf{i}\right)$ as $\mathbf{i}$ ranges over ${\mathbb{B}}^n$. To enhance comprehension, we visualize the details below.
• Given the pattern vector $\mathbf{p}$=$p_{2^n-1}$…$p_1$$p_0$ of f, its negation, denoted by $\overline{\mathbf{p}}$, is the pattern vector $\overline{p_{2^n-1}}$…$\overline{p_1}$$\overline{p_0}$, which corresponds to the function $\overline{f}$.

It is clear by the preceding Definition 5 that there is a one-to-one correspondence between Boolean functions and patterns vectors. We could say that a Boolean function and its pattern vector are the two sides of the same coin. Therefore, just as knowing the behavior of a Boolean function enables the construction of its pattern vector, conversely, the pattern vector contains all the information necessary to reconstruct the Boolean function. This duality is emphasized by Figure 4.

Definition 6 

(Orthogonal pattern vectors). Consider the distinct pattern vectors $\mathbf{p}$ and $\mathbf{q}$, corresponding to the Boolean functions $f,g:{\mathbb{B}}^n\to \mathbb{B}$. $\mathbf{p}$ and $\mathbf{q}$ are orthogonal if $\mathbf{p}\oplus \mathbf{q}$ contains $2^{n-1}$ 0 s and $2^{n-1}$ 1 s.

Definition 7 

(Imbalance ratio). Given a pattern vector, $\mathbf{p}$, of length $2^n$, let $0_{\mathbf{p}}$ and ${\mathbb{1}}_{\mathbf{p}}$ denote the number of 0s and 1s appearing in $\mathbf{p}$. The imbalance ratio of $\mathbf{p}$ is defined as

$$\begin{array}{c}\hfill \rho min\left\{{\displaystyle \frac{0_{\mathbf{p}}}{2^n}},{\displaystyle \frac{{\mathbb{1}}_{\mathbf{p}}}{2^n}}\right\}.\end{array}$$

(10)

If $\mathbf{p}$ is the pattern vector of f, we shall also say that ρ is the imbalance ratio of f. In the same spirit, if P and F are a collection of pattern vectors and a collection of Boolean functions with the common imbalance ratio ρ, respectively, we will speak of ρ being the imbalance ratio of P and F.

As we pointed out previously, we visualize the execution of the BFPQC algorithm as the evolution of the Classification Game played between our prolific stars Alice and Bob, according to the following rules.

(G₁)

Bob is free to choose any Boolean function, provided that it belongs to the promised class of functions.

(G₂)

Bob wins the game if Alice fails to recognize the chosen function with one try. Otherwise, Alice is the winner.

(G₃)

In terms of implementing the game as a quantum circuit, Bob chooses the hidden oracle, while Alice furnishes the classifier.

Before we proceed to introduce more technical machinery, we give a toy scale example to build intuition.

Example 1 

(A toy scale example). Let us consider the following two families of Boolean functions defined on ${\mathbb{B}}^2$.

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}\hfill f_0(x_1,x_0)& :=\overline{x_1}\wedge \overline{x_0}\hfill \\ \hfill f_1(x_1,x_0)& :=\overline{x_1}\wedge x_0\hfill \\ \hfill f_2(x_1,x_0)& :=x_1\wedge \overline{x_0}\hfill \\ \hfill f_3(x_1,x_0)& :=x_1\wedge x_0\hfill \end{array}\right\}\end{array}$$

(11)

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}\hfill g_0(x_1,x_0)& :=x_1\vee x_0\hfill \\ \hfill g_1(x_1,x_0)& :=x_1\vee \overline{x_0}\hfill \\ \hfill g_2(x_1,x_0)& :=\overline{x_1}\vee x_0\hfill \\ \hfill g_3(x_1,x_0)& :=\overline{x_1}\vee \overline{x_0}\hfill \end{array}\right\}\end{array}$$

(12)

Their truth values and pattern vectors are given in

Table 1. The truth values and the pattern vectors of $f_0,f_1,f_2$, and $f_3$.

	00	01	10	11	Pattern Vector
$f_0$	1	0	0	0	0001
$f_1$	0	1	0	0	0010
$f_2$	0	0	1	0	0100
$f_3$	0	0	0	1	1000

and

Table 2. The truth values and the pattern vectors of $g_0,g_1,g_2$, and $g_3$.

	00	01	10	11	Pattern Vector
$g_0$	0	1	1	1	1110
$g_1$	1	0	1	1	1101
$g_2$	1	1	0	1	1011
$g_3$	1	1	1	0	0111

below.

The four functions $f_0,f_1,f_2$, and $f_3$ exhibit a common pattern: for precisely one element, $\mathbf{x}\in {\mathbb{B}}^2$, their value is 1, while for the remaining three elements their value is 0. Symmetrically, the four functions $g_0,g_1,g_2$, and $g_3$ exhibit an analogous motif, i.e., for precisely one element, $\mathbf{x}\in {\mathbb{B}}^2$, their value is 0, while for the remaining three elements their value is 1. Obviously, this is because $g_i=\overline{f_i}$, $0\le i\le 3$. The imbalance ratio, ρ, for both families is the same, namely $\rho ={\displaystyle \frac{1}{4}}$. The four pattern vectors shown in Table 1 are pairwise orthogonal and constitute the set $P_2=\{0001,0010,0100,1000\}$. An important observation at this point is that, although $f_i$ and $g_i$ are logically different, within our quantum context $f_i$ and $g_i$ are indistinguishable because they lead to the same state.

For future reference, we gather the Boolean functions $f_i$ into one set, which we call $F_2$. Given any function in $F_2$, it is easy to construct the corresponding oracle using standard quantum gates. Accordingly, it is possible to distinguish among the four Boolean functions $f_i$. Hence, given the promise that the unknown function, f, is one of the above four Boolean functions, and having the corresponding oracle, the aim of the Classification Game is to construct a quantum circuit that allows Alice to win with absolute certainty, i.e., with a probability of $1.0$. The initial segment of such a circuit is shown in Figure 5. $U_f$ is the oracle of the hidden function, chosen by Bob. After the application of the unitary transform, $U_f$, the state of the quantum input register, $IR$, will be $|{\psi }_2\rangle$. As is the norm in such cases, we ignore from now on the output register, $OR$, since its state remains |−〉. It is quite straightforward to verify the precise dependency of $|{\psi }_2\rangle$ on each of the functions in $F_2$, which is shown in

Table 3. The four Boolean functions $f_0,f_1,f_2$, and $f_3$ drive the quantum circuit of Figure 5 to the four different states shown below. In contrast, $f_i$ and $g_i,0\le i\le 3$, are indistinguishable because they lead to the same state.

The State $|{\mathit{\psi }}_2\rangle$
Function	$|{\mathit{\psi }}_{\mathbf{2}}\rangle$
$f_0$	$-{\displaystyle \frac{1}{2}}|00\rangle +{\displaystyle \frac{1}{2}}|01\rangle +{\displaystyle \frac{1}{2}}|10\rangle +{\displaystyle \frac{1}{2}}|11\rangle$
$f_1$	$-{\displaystyle \frac{1}{2}}|00\rangle -{\displaystyle \frac{1}{2}}|01\rangle +{\displaystyle \frac{1}{2}}|10\rangle +{\displaystyle \frac{1}{2}}|11\rangle$
$f_2$	$-{\displaystyle \frac{1}{2}}|00\rangle +{\displaystyle \frac{1}{2}}|01\rangle -{\displaystyle \frac{1}{2}}|10\rangle +{\displaystyle \frac{1}{2}}|11\rangle$
$f_3$	$-{\displaystyle \frac{1}{2}}|00\rangle +{\displaystyle \frac{1}{2}}|01\rangle +{\displaystyle \frac{1}{2}}|10\rangle -{\displaystyle \frac{1}{2}}|11\rangle$
$g_0$	$-{\displaystyle \frac{1}{2}}|00\rangle -{\displaystyle \frac{1}{2}}|01\rangle -{\displaystyle \frac{1}{2}}|10\rangle -{\displaystyle \frac{1}{2}}|11\rangle$
$g_1$	$-{\displaystyle \frac{1}{2}}|00\rangle +{\displaystyle \frac{1}{2}}|01\rangle -{\displaystyle \frac{1}{2}}|10\rangle -{\displaystyle \frac{1}{2}}|11\rangle$
$g_2$	$-{\displaystyle \frac{1}{2}}|00\rangle -{\displaystyle \frac{1}{2}}|01\rangle +{\displaystyle \frac{1}{2}}|10\rangle -{\displaystyle \frac{1}{2}}|11\rangle$
$g_3$	$-{\displaystyle \frac{1}{2}}|00\rangle -{\displaystyle \frac{1}{2}}|01\rangle -{\displaystyle \frac{1}{2}}|10\rangle +{\displaystyle \frac{1}{2}}|11\rangle$

. The important observation here is that each of the four $f_i$ leads to a different $|{\psi }_2\rangle$, which means that we can distinguish and classify them. However, as expected, state $|{\psi }_2\rangle$ is the same for each pair of functions $f_i$ and $g_i$, which means that they are indistinguishable.

Alice now employs a unitary transform that can differentiate among the four Boolean functions $f_0,f_1,f_2$, and $f_3$, such as $Q_2$. The matrix representation of $Q_2$ is given by Equation (13). It is easy to verify that the action of $Q_2$ on the four possible states, $|{\psi }_2\rangle$, leads to the states shown in

Table 4. This table contains the outcome of the action of $Q_2$ on the four possible states, $|{\psi }_2\rangle$, outlined in Table 3.

	${\mathit{f}}_0$	${\mathit{f}}_1$	${\mathit{f}}_2$	${\mathit{f}}_3$
${\mathbf{Q}}_2$ action on $|{\mathit{\psi }}_{\mathbf{2}}\rangle$	$Q_2\left[\begin{array}{c}-{\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\end{array}\right]$	$Q_2\left[\begin{array}{c}{\displaystyle \frac{1}{2}}\\ -{\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\end{array}\right]$	$Q_2\left[\begin{array}{c}{\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ -{\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\end{array}\right]$	$Q_2\left[\begin{array}{c}{\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ {\displaystyle \frac{1}{2}}\\ -{\displaystyle \frac{1}{2}}\end{array}\right]$
Outcome	$\left[\begin{array}{c}1\\ 0\\ 0\\ 0\end{array}\right]=|00\rangle$	$\left[\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right]=|01\rangle$	$\left[\begin{array}{c}0\\ 0\\ 1\\ 0\end{array}\right]=|10\rangle$	$\left[\begin{array}{c}0\\ 0\\ 0\\ 1\end{array}\right]=|11\rangle$

, which are precisely the basis kets of the computational basis $B_4$. It is straightforward to build $Q_2$ using standard quantum gates readily available in contemporary quantum computers. Below we show in Figure 6 such a construction that requires only Hadamard, Z, and controlled-Z gates:

Regarding the schematic of Figure 5, we note the following.

• $I{R}_0$ is the least significant qubit and $I{R}_1$ is the most significant qubit of the quantum input register, $IR$, that contains 2 qubits.
• $OR$ is the single-qubit output register that is initialized to state |−〉.
• H is the Hadamard transform.
• $U_f$ is the unitary transform that is based on the oracle for the unknown function, f, and satisfies relation (4).

$$\begin{array}{c}\hfill Q_2=(H\otimes H)CZ(Z\otimes Z)(H\otimes H)\end{array}$$

(13)

$$\begin{array}{c}{Q}_2=\left[\begin{array}{cccc}\hfill -{\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}\\ \hfill {\displaystyle \frac{1}{2}}& \hfill -{\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}\\ \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill -{\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}\\ \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill {\displaystyle \frac{1}{2}}& \hfill -{\displaystyle \frac{1}{2}}\end{array}\right]\hfill \end{array}$$

(14)

Therefore, the quantum algorithm that classifies each Boolean function contained in $F_2$ can be visualized by the quantum circuit depicted in Figure 7. Alice surely wins because the action of the classifier $Q_2$ results in the final state of the system being one of the four basis kets of the computational basis $B_4=\left\{\right|00\rangle ,|01\rangle ,|10\rangle ,|11\rangle \}$. Specifically, if the oracle encodes $f_i$, the final state will be $|\mathbf{i}\rangle$, where $\mathbf{i}$ is the binary representation of the index i, $0\le i\le 3$. Therefore, upon the final measurement, Alice will surmise the correct hidden function with a probability of $1.0$.

An actual implementation of the abstract quantum circuit of Figure 7 in Qiskit [41] using the oracle for the function $f_2$ is depicted in Figure 8. Let us clarify that in all the figures in this paper the qubit numbering follows the “little-endian” convention, where is the rightmost qubit is the least significant qubit (LSQ), and the leftmost qubit is the most significant qubit (MSQ).

Figure 9 shows the state of the quantum circuit of Figure 8 after the oracle but before the action of $Q_2$. The main property of $Q_2$ is its ability to distinguish and classify the superpositions of the basis kets of the computational basis $B_4=\left\{\right|00\rangle ,|01\rangle ,|10\rangle ,|11\rangle \}$ in which exactly three kets appear with same sign and the fourth ket appears with the opposite sign. Thus, the state of the quantum circuit after the action of $Q_2$ will be |10〉, as depicted in Figure 10.

We observe that the four different Boolean functions $f_i$ give rise to four different orthonormal states, $|{\psi }_2\rangle$. Thus, the task of differentiating among the four Boolean functions $f_i$ can be reduced to the task of using a unitary transform that maps the four orthonormal states $|{\psi }_2\rangle$ to the computational basis $B_4=\left\{\right|00\rangle ,|01\rangle ,|10\rangle ,|11\rangle \}$.

4. The General Form of the BFPQC Algorithm

In this section we present the general form of the BFPQC algorithm. For this purpose, we extend the definitions given in the previous section.

Definition 8 

(Pattern basis). A pattern basis of rank $2n$, $n\ge 1$ is a collection of $2^{2n}$ pairwise orthogonal pattern vectors of length $2^{2n}$, denoted by $P_{2n}$.

The initial pattern basis, $P_2$, is the set consisting of the following four pairwise orthogonal pattern vectors:

$$\begin{array}{c}\hfill P_2:=\{0001,0010,0100,1000\}.\end{array}$$

(15)

Starting from $P_2$, we may define an infinite hierarchy of pattern bases. The details are explained below.

Definition 9 

(Pattern hierarchy). We recursively define a hierarchy of pattern bases $P_{2n}$, $n\ge 1$ as follows.

(PH₀)

If $n=1$, the corresponding pattern basis is the set $P_2$, as defined by (15).

(PH₁)

Let $P_{2n}$ contain the pattern vectors ${\mathbf{p}}_0,{\mathbf{p}}_1,\dots ,{\mathbf{p}}_m$; then, the pattern basis $P_{2(n+1)}$ consists of the pattern vectors with the following syntax structure:

$$\begin{array}{cc}\hfill P_{2(n+1)}:=\{& {\mathbf{p}}_0{\mathbf{p}}_0{\mathbf{p}}_0{\overline{\mathbf{p}}}_0,{\mathbf{p}}_1{\mathbf{p}}_1{\mathbf{p}}_1{\overline{\mathbf{p}}}_1,\dots ,{\mathbf{p}}_m{\mathbf{p}}_m{\mathbf{p}}_m{\overline{\mathbf{p}}}_m\hfill \\ \hfill & {\mathbf{p}}_0{\mathbf{p}}_0{\overline{\mathbf{p}}}_0{\mathbf{p}}_0,{\mathbf{p}}_1{\mathbf{p}}_1{\overline{\mathbf{p}}}_1{\mathbf{p}}_1,\dots ,{\mathbf{p}}_m{\mathbf{p}}_m{\overline{\mathbf{p}}}_m{\mathbf{p}}_m,\hfill \\ \hfill & {\mathbf{p}}_0{\overline{\mathbf{p}}}_0{\mathbf{p}}_0{\mathbf{p}}_0,{\mathbf{p}}_1{\overline{\mathbf{p}}}_1{\mathbf{p}}_1{\mathbf{p}}_1,\dots ,{\mathbf{p}}_m{\overline{\mathbf{p}}}_m{\mathbf{p}}_m{\mathbf{p}}_m,\hfill \\ \hfill & {\overline{\mathbf{p}}}_0{\mathbf{p}}_0{\mathbf{p}}_0{\mathbf{p}}_0,{\overline{\mathbf{p}}}_1{\mathbf{p}}_1{\mathbf{p}}_1{\mathbf{p}}_1,\dots ,{\overline{\mathbf{p}}}_m{\mathbf{p}}_m{\mathbf{p}}_m{\mathbf{p}}_m,\}\hfill \end{array}$$

(16)

An easy conclusion of the above definition is that every $P_{2n}$, $n\ge 1$, contains $2^{2n}$ pairwise orthogonal pattern vectors. Henceforth, we shall assume that the $2^{2n}$ pattern vectors contained in $P_{2n}$ are enumerated as ${\mathbf{p}}_0,{\mathbf{p}}_1,\dots ,{\mathbf{p}}_{2^{2n}-1}$ according to the order prescribed by Formula (16).

Example 2 

(Pattern basis $P_4$). To facilitate the understanding of Definition 9, we list $P_4$ in

Table 5. This table contains the pattern vectors of $P_4$.

${\mathit{P}}_2$ Pattern Vectors	${\mathit{p}}_0=0001$	${\mathit{p}}_1=0010$	${\mathit{p}}_2=0100$	${\mathit{p}}_3=1000$
${\mathbf{p}}_i{\mathbf{p}}_i{\mathbf{p}}_i{\overline{\mathbf{p}}}_i$	${\mathbf{r}}_0:0001000100011110$	${\mathbf{r}}_1:0010001000101101$	${\mathbf{r}}_2:0100010001001011$	${\mathbf{r}}_3:1000100010000111$
${\mathbf{p}}_i{\mathbf{p}}_i{\overline{\mathbf{p}}}_i{\mathbf{p}}_i$	${\mathbf{r}}_4:0001000111100001$	${\mathbf{r}}_5:0010001011010010$	${\mathbf{r}}_6:0100010010110100$	${\mathbf{r}}_7:1000100001111000$
${\mathbf{p}}_i{\overline{\mathbf{p}}}_i{\mathbf{p}}_i{\mathbf{p}}_i$	${\mathbf{r}}_8:0001111000010001$	${\mathbf{r}}_9:0010110100100010$	${\mathbf{r}}_{10}:0100101101000100$	${\mathbf{r}}_{11}:1000011110001000$
${\overline{\mathbf{p}}}_i{\mathbf{p}}_i{\mathbf{p}}_i{\mathbf{p}}_i$	${\mathbf{r}}_{12}:1110000100010001$	${\mathbf{r}}_{13}:1101001000100010$	${\mathbf{r}}_{14}:1011010001000100$	${\mathbf{r}}_{15}:0111100010001000$

to show how it is derived from $P_2=\{0001,0010,0100,1000\}$.

Definition 10 

(Functions from patterns). To each pattern basis $P_{2n}$=$\{{\mathbf{p}}_0,{\mathbf{p}}_1,$ …$,{\mathbf{p}}_{2^{2n}-1}\}$ of rank $2n$, we associate the class $F_{2n}$=$\{f_0,f_1,$ …$,f_{2^{2n}-1}\}$ of Boolean functions from ${\mathbb{B}}^{2n}$ to $\mathbb{B}$, such that ${\mathbf{p}}_i$ is the pattern bit vector corresponding to $f_i$, $0\le i\le 2^{2n}-1$.

Hence, a hierarchy, $P_{2n}$, of pattern bases induces a corresponding hierarchy, $F_{2n}$, of classes of Boolean functions. In what follows we shall also assume that the $2^{2n}$ Boolean functions contained in $F_{2n}$ are enumerated as $f_0,f_1,\dots ,f_{2^{2n}-1}$ following the same enumeration with the pattern vectors of $P_{2n}$. By construction, the pattern vectors and, consequently, the pattern bases satisfy the following important relations.

(R₁)

As we have mentioned in Example 1, the imbalance ratio, $\rho$, of $P_2=\{1000$, 0100, 0010, $0001\}$ is $\rho ={\displaystyle \frac{1}{4}}$.

(R₂)

The recursive Definition 9 of the pattern hierarchy implies that the imbalance ratio satisfies the recurrence relation given below

$$\begin{array}{c}\hfill {\rho }_{2n}={\displaystyle \frac{1}{4}}+{\displaystyle \frac{1}{2}}{\rho }_{2n-2}(n\ge 2),\end{array}$$

(17)

where ${\rho }_{2n-2}$ and ${\rho }_{2n}$ are the imbalance ratios of $P_{2n-2}$ and $P_{2n}$, respectively.

(R₃)

After some manipulation, the above recurrence relation can be transformed into the next closed form

$$\begin{array}{c}\hfill {\rho }_{2n}={\displaystyle \frac{1}{2}}-{\displaystyle \frac{1}{2^{n+1}}}(n\ge 1).\end{array}$$

(18)

(R₄)

The above closed-form formula enables us to surmise that

$$\begin{array}{c}\hfill {\rho }_{2n}<{\displaystyle \frac{1}{2}}(n\ge 1),\end{array}$$

(19)

which proves that every pattern basis and all classes of Boolean functions in their respective hierarchies have the imbalance ratio $<{\displaystyle \frac{1}{2}}$, or, in simpler terms, all the Boolean functions we classify are indeed imbalanced as we have previously asserted.

Our purpose is to realize the Boolean Function Pattern Quantum Classifier algorithm through a family of quantum circuits denoted by QCPC_2n, $n\ge 1$, such that QCPC_2n classifies the class of Boolean functions $F_{2n}$, which consist of functions that follow the motif prescribed by the elements of the pattern basis $B_{2n}$. In these quantum circuits, the critical component for the classification is the $Q_{2n}$ unitary classifier, defined below.

Definition 11 

(A hierarchy of unitary classifiers). We recursively define a hierarchy of unitary classifiers, denoted by $Q_{2n}$, $n\ge 1$, as follows.

(QH₀)

If $n=1$, the corresponding classifier is $Q_2$, as expressed by (13) with the matrix representation given by Figure 6.

(QH₁)

Given $Q_{2n}$, the classifier $Q_{2(n+1)}$ is defined as

$$\begin{array}{c}\hfill Q_{2(n+1)}:=Q_2\otimes Q_{2n}=Q_2^{\otimes (n+1)}(n\ge 1).\end{array}$$

(20)

Example 3 

(Unitary classifier $Q_4$). It is instructive to show in detail how the matrix representation of the unitary classifier $Q_4$ is derived. By Definition 11, we know that

(21)

We use the unitary classifier $Q_{2n}$, $n\ge 1$, as the main component in the construction of the family of quantum circuits QCPC_2n, for the classification of the class of Boolean functions $F_{2n}$.

Definition 12 

(A family of quantum classifiers). To each unitary classifier $Q_{2n},n\ge 1$, we associate the quantum circuits QCPC_2n, for the classification of the class of Boolean functions $F_{2n}$.

• The first member of this family, the QCPC₂ quantum circuit, takes the form depicted in Figure 7 and can classify the Boolean functions in $F_2$.
• The general QCPC_2n quantum circuit takes the abstract form visualized in Figure 11. It is endowed with the oracle $U_f$ encoding the behavior of the Boolean function f, which is promised to belong to $F_{2n}$.

Therefore, the abstract quantum circuit that implements the BFPQC algorithm for the classification of the class of Boolean functions $F_{2n},n\ge 1$, is outlined in Figure 11. To avoid any ambiguity, we explain the notation used in this figure.

• $IR$ is the quantum input register that contains $2n$ qubits and starts its operation at state $|\mathbf{0}\rangle$.
• $OR$ is the single-qubit output register initialized to |−〉.
• H is the Hadamard transform.
• $U_f$ is the unitary transform corresponding to the oracle for the unknown function, f. The latter is promised to be an element of $F_{2n}$.
• $Q_2$ is the fundamental building block of $Q_{2n}$, as evidenced by Equation (20).

Classification works as follows: the Boolean functions contained in $F_{2n}$ are enumerated as $f_0,f_1,\dots ,f_{2^{2n}-1}$. Assuming the oracle encodes the function $f_i$ with index i, the outcome of the final measurement of the quantum circuit QCPC_2n after the action of the classifier $Q_2^{\otimes 2n}$ will be $|\mathbf{i}\rangle$, where $\mathbf{i}$ is the binary representation of the index i, i.e., one of the basis kets of the computational basis. Our algorithm is optimal because it requires just a single query to classify the hidden function.

The method we used to devise the BFPQC algorithm is visualized in Figure 12. We are confident that this methodology is general and fruitful, in the sense that it can be used as a starting point to define additional quantum classification algorithms by establishing different hierarchies of pattern bases and classifiers.

We close this section by giving a more interesting example targeting functions of $F_4$.

Example 4 

(Classifying functions of $F_4$). Let us assume that Bob has to choose a Boolean function from $F_4$, the promised class of functions in this case. Say that Bob chooses $f_3$, the behavior of which is given by the pattern vector ${\mathbf{r}}_3:1000100010000111$, listed in Example 2. Alice makes her move by employing the classifier $Q_4=Q_2^{\otimes 2}$. In this case, the concrete implementation in Qiskit [41] of the general quantum circuit of Figure 11 takes the form shown in Figure 13, where Bob uses the oracle for the function $f_3$ and Alice the classifier $Q_4$.

After the oracle, and before the action of the classifier, the state of the system is shown in Figure 14. After the action of the classifier, the state of the system is just $|\mathbf{0011}\rangle$. Therefore, measuring the quantum circuit depicted in Figure 13 will output the bit vector 0011 with probability 1 (as corroborated by the measurements contained in Figure 15), which is the binary representation of the index of $f_3$. Alice surely wins the game, as anticipated.

Execution on IBM quantum computers.

After validating the correctness of the quantum circuit depicted in Figure 13 via simulation, we used Qiskit to execute it on a real IBM quantum computer. At the moment of running the experiment, the backends that were available to us (via our free-tier account) were ibm_brisbane (127 qubits) and ibm_sherbrooke (127 qubits). Both IBM Brisbane and IBM Sherbrooke quantum computers are 127-qubit backends based on IBM’s Eagle r3 processor, making them architecturally similar. They are designed for utility-scale quantum computing, meaning that they are capable of running complex algorithms and physics simulations that push the boundaries of classical computation, and suit our circuit’s modest requirements (number of qubits and number of gates). Each time we picked the least busy backend with enough qubits using the typical command:

backend = service.least_busy(simulator=False, operational=True,

                  min_num_qubits=5)

The operation of the BFPQC algorithm is formalized in Theorem 1.

Theorem 1 

(Classification via the BFPQC algorithm). Let $f_i$, $0\le i\le 2^{2n}-1$ be a Boolean function contained in the class $F_{2n}$=$\{f_0,f_1,$ …$,f_{2^{2n}-1}\}$. Upon measuring the quantum circuit QCPC_2n containing the oracle for $f_i$ and the unitary classifier $Q_{2n}$, we obtain with a probability of $1.0$$|\mathbf{i}\rangle$, where $\mathbf{i}$ is the binary representation of the index i, and $|\mathbf{i}\rangle$ is one of the basis kets of the computational basis.

5. Discussion and Conclusions

This section contains the complexity analysis of the BFPQC algorithm followed by a brief discussion summarizing the novelties of this work. We begin by considering the complexity aspects of the BFPQC algorithm.

5.1. Discussion on Complexity

From a classical viewpoint, we may devise an oracular deterministic algorithm that can solve the classification problem for functions defined via pattern bases as in Definition 10. Such an algorithm can achieve this task by querying the oracle on different inputs. As we have explained in Section 2, the standard measure of complexity in oracular algorithms is the query complexity, i.e., the number of queries to the oracle used by the algorithm. In that respect, the proposed quantum algorithm BFPQC is superior to any deterministic classical algorithm. This is because the BFPQC algorithm can conclusively identify any function in $F_{2n}$, $n\ge 1$, with just a single query to the oracle, whereas any deterministic classical algorithm requires polynomially more queries. To be exact, if $c_{2n}$ is the number of calls to the oracle that any deterministic classical algorithm makes in the worst case, in order to classify any function in $F_{2n}$, we can show with induction on n that

$$\begin{array}{c}\hfill c_{2n}=3+2(n-1)(n\ge 1).\end{array}$$

(22)

Implementation-wise, the quantum circuits QCPC_2n used for the execution of the BFPQC algorithm require very modest quantum resources. To quantify these resources, we use standard terminology that can be found in most textbooks (see for details [44,45,46,47]). Recall that the depth of a quantum circuit is the maximal sequence of one- and two-qubit gates between the initial state preparation and the final measurement, the width of a quantum circuit is the total number of qubits (including ancillae qubits), and the size is the total number of gates used. To make an analogy with classical computation, one could say that the depth and width of a quantum circuit correspond to its time and space complexity. The quantum circuit QCPC_2n depicted in Figure 11, which implements the classification, has constant depth, excluding the oracle, namely 5, taking into account that the subcircuits realizing the classifier $Q_2$ have depth 4 (recall Figure 6). Its width is $2n+1$, where the constant 1 is due to the output qubit $OR$.

5.2. Other Possible Hierarchies of Boolean Functions

As we have shown, the proposed BFPQC algorithm can classify imbalanced Boolean functions that belong to the hierarchy of classes of Boolean functions $F_2$, $F_4$, …, $F_{2n}$, …. This hierarchy of Boolean functions is constructed from the corresponding hierarchy of imbalanced pattern bases $P_2$, $P_4$, …, $P_{2n}$, …, as ordained by Definition 10. Taking into account the fact that our purpose was to tackle imbalanced Boolean functions, we see that the initial pattern basis in this hierarchy must necessarily be $P_2$ (recall Definition 9) because this is the least such basis that exhibits imbalance in terms of the length of the pattern vector. It is trivial to verify that there can be no pattern basis with a pattern vector of length 2 that captures imbalance. For instance, the pattern basis $B_2:=\{00,01\}$ consists of pattern vectors that correspond to a constant and a perfectly balance function. Regarding the rest of the hierarchy, there could be variations by appropriately modifying Definition 11. The simplest possibility would be to define a different hierarchy of unitary classifiers as follows

$$\begin{array}{c}\hfill H\otimes Q_2,H^{\otimes 2}\otimes Q_2,\dots .\end{array}$$

(23)

The above approach leads to a totally different hierarchy of classes of Boolean functions $G_2$, $G_3$, …, $G_n$, $G_{n+1}$, …. However, excluding $G_2$, all other classes, $G_n$, contain both perfectly balanced and imbalanced functions. In our view, it is preferable to choose the construction outlined in Definition 11 because it guarantees that all Boolean functions in the same class, $F_{2n}$, are imbalanced and with exactly the same imbalance ratio, ${\rho }_{2n}$, as given by Equation (18).

5.3. Conclusions

The starting point of this work was the realization that, although the relevant literature is full of sophisticated studies that extend and generalize the Deutsch–Jozsa algorithm and investigate balanced Boolean functions, it still lacks works focusing on imbalanced Boolean functions. By imbalanced we mean Boolean functions that are characterized by an unequal number of elements in their domain that take the values 0 and 1. This article presents a new quantum algorithm aimed at categorizing a particular hierarchy of imbalanced Boolean function classes.

For each positive integer $n\ge 1$, this hierarchy encompasses a class, $F_{2n}$, of $2n$-ary Boolean functions, which are delineated based on their behavioral traits. A distinguishing characteristic of all functions within the same class is their common imbalance ratio. Our algorithm enables classification in a clear and intuitive way, as the final measurement identifies the unknown function with a probability of $1.0$. It is crucial to emphasize that the proposed algorithm is an optimal oracular algorithm, capable of categorizing the specified functions with a single query to the oracle. We note that, within this quantum context, $f_i$ and its negation, $\overline{f_i}$, are indistinguishable because they lead to the same state.

In closing, we emphasize that, in addition to a concrete algorithm, we offer a comprehensive description of the methodology utilized in the creation of this algorithm. This is done with the hope that it will prove both general and advantageous, as it can be easily modified and expanded to address other categories of imbalanced Boolean functions that exhibit diverse behavioral patterns. This can be easily achieved by appropriately modifying Definition 9 to include different pattern bases.