Classical-Quantum Separations in Certain Classes of Boolean Functions– Analysis using the Parity Decision Trees

04/27/2020 ∙ by Chandra Sekhar Mukherjee, et al. ∙ 0

In this paper we study the separation between the deterministic (classical) query complexity (D) and the exact quantum query complexity (Q_E) of several Boolean function classes using the parity decision tree method. We first define the Query Friendly (QF) functions on n variables as the ones with minimum deterministic query complexity (D(f)). We observe that for each n, there exists a non-separable class of QF functions such that D(f)=Q_E(f). Further, we show that for some values of n, all the QF functions are non-separable. Then we present QF functions for certain other values of n where separation can be demonstrated, in particular, Q_E(f)=D(f)-1. In a related effort, we also study the Maiorana McFarland (M-M) type Bent functions. We show that while for any M-M Bent function f on n variables D(f) = n, separation can be achieved as n/2≤ Q_E(f) ≤⌈3n/4⌉. Our results highlight how different classes of Boolean functions can be analyzed for classical-quantum separation exploiting the parity decision tree method.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

Query Complexity is a model of computation in which a function is evaluated using queries to the variables . The query complexity model has been widely studied under different computational scenarios, such as classical deterministic model and exact quantum model Bool1 . While the study can be conducted for functions with any finite range, Boolean functions are most widely studied in this area, for their simplicity as well as the richness in terms of generalization. Substantial work has been completed on asymptotic separation of query complexity under different models AMB1 ; ANDk ; AMB2 and in finding separation between classical deterministic and exact quantum query complexity models for different Boolean functions, such as the  AMB4 functions. One may note that the query complexity of a Boolean function does not necessarily relate to its optimal circuit depth. However, in many cases the circuit obtained using the query complexity model remains the most optimal till date. The query complexities of functions under different computational models also form a better picture of the advantage offered by quantum computers in function evaluation. In this regard finding classical-quantum separation and the query complexity of Boolean functions in different computational model remains a non trivial and interesting problem. We analyze this separation for two Boolean Function classes. The first class comprises of Query Friendly functions, which we define for a given as Boolean functions with influencing variables with least possible deterministic query complexity. The second class is that of the Maiorana McFarland (M-M) Bent functions MM1 on variables, which is a large class of cryptographically important Boolean functions. The study of (M-M) Bent functions as a generalized class is also interesting because this class consists of many functions which are not isomorphic to each other.

A common method of forming Quantum Algorithms in the query complexity model is using the parity function to calculate the parity of two bits using a single query. This method is also practical for implementation in a noisy quantum computer as the bits in superposition are measured after each oracle access. In this direction we use this method of calculating parity of variables in a disciplined manner along with combinatorial reductions to find separation in query complexity between the classical deterministic and the exact quantum model in the aforementioned Boolean Function classes.

We now introduce some notations and the concept of classical and quantum oracles and describe the deterministic classical and exact quantum query model in details.

Algebraic Normal Form (ANF): It is known that given any total Boolean function, there exists a unique multivariate polynomial defined over GF(2) which exactly defines the function. Formally, one can write,

where and . The Hamming weight of , , is defined as where the sum is over ring of integers. The algebraic degree of , , is defined as .

We also define the term influencing variables in this context. We call a variable of a function influencing if there exists a set of values such that

The number of influencing variables is also represented as the number of variables present in the ANF of the corresponding function.

It is also important to note that the algebraic degree of a Boolean function is different from the polynomial degree of the function, which commonly used in obtaining lower bounds of query algorithms.


Classical and Quantum Oracle: In the query complexity model, the value of any variable can only be queried using an oracle. An oracle is a black-box which can perform a particular computation. In the classical model, an oracle accepts an input and output the value of the variable . In the quantum model, the oracle needs to be reversible. It is represented as an unitary which functions as follows.

Figure 1 represents the working of an oracle in the quantum complexity model, which is similar to what is presented in (oneQ, , Fig. 3)

Figure 1: Working of a quantum oracle

The query complexity of a function is the maximum number of times this oracle needs to be used to evaluate the value of the function for any value of the variables . We will be focusing on total Boolean functions from here on, i.e., . Let us now specify the models.


Deterministic (Classical) Query Complexity: The minimum number of queries that a function needs to be evaluated using a deterministic algorithm is called its Deterministic Query Complexity (). We generally omit the word ‘classical’. A query based classical deterministic algorithm for evaluating a Boolean function can be expressed as a rooted decision tree as follows.

In this model, every internal node corresponds to a query to a variable . Each leaf is labeled as either or . The tree is traversed from the root of the tree till it reaches a leaf in the following manner. Every internal node has exactly two children and depending on the outcome of the query ( or respectively), one of the two children are visited (left or right, respectively). That is this is a binary tree. The leaf nodes correspond to the output of for different inputs. Every decision tree uniquely defines a Boolean function which we can obtain by deriving the Algebraic Normal Form (ANF) from a given tree. For example, the ANF of the Boolean function corresponding to the tree shown in Figure 2 is .

Figure 2: Example of a decision tree

Corresponding to a function, there can be many Deterministic Query Algorithms that can evaluate it. The depth of a decision tree is defined as the number of edges encountered in the longest root to leaf path. Given , the shortest depth decision tree representing the function, is called the optimal decision tree of and the corresponding depth is termed as the Deterministic classical complexity of , denoted as . We further describe the following notations related to the decision tree model.

  • Let there be a decision tree corresponding to a function such that no variable appears twice in the tree. We can then identify an internal node with the variable that it queries. In such a case we use the notation to denote the left or right children of the internal node which queries the variable where c is or , respectively.

  • We also define a fully-complete binary tree. We call a binary tree fully-complete if it has depth and there are total internal nodes, i.e. a fully complete binary tree is a -depth decision tree in which every internal node has two children and all the nodes in the -th level are parents of leaves. It is to be noted that this differs from a complete binary tree, in which every level other than the last is completely filled, and in the last level all the nodes are as far left as possible.


Exact Quantum Query Complexity : A Quantum Query Algorithm is defined using a start state and a series of unitary Transformations

where the unitary operations are indifferent of the values of the variables and is the oracle as defined above. Therefore, the final state of the algorithm is

and the output is decided by some measurement of the state . A quantum algorithm is said to exactly compute if for all

it outputs the value of the function correctly with probability 1. The minimum number of queries needed by a Quantum Algorithm to achieve this is called the Exact Quantum Query Complexity

of the function.


Isomorphism( PNP equivalence): Two functions and over are called isomorphic (PNP equivalent) if the ANF of can be derived from ANF of by negation and permutation of the input variables of and by adding the constant term in the ANF, that is negation of the output. If and are isomorphic then and  (exact, , Section 2.2).


Separability : A Boolean function is called separable if and non-separable otherwise.

In this paper we concentrate on the deterministic and exact quantum query complexity of different Boolean function classes. There are other computational models such as the classical randomized model and the bounded error quantum model AMB3 and there exists rich literature on work on these models as well. However, those are not in the scope of this work.

In this regard one may note that the work by Barnum et.al sdp can be used to find the exact quantum query complexity of any function on variables by repetitively solving semi definite programs (SDP). Montanaro et.al exact have used this method to find exact quantum query complexity of all Boolean functions upto four variables as well as describe a procedure of formulating the quantum algorithm to achieve the said exact quantum query complexity. This method is not yet found to be suitable for finding the exact quantum query complexity of a general classes of Boolean functions. Additionally, the SDP are resource intensive in nature and solving the SDP for large values of is computationally challenging. But for the cases where the number of variables is low, this does offer an exhaustive view of the exact quantum query complexities of all Boolean functions.

As an example, in a very recent paper Chen et.al oneQ have shown that or are the only Boolean functions with . However the work of Montanaro et.al (exact, , Section 6.1) show that the Boolean functions with or lesser variables and are

  • The single variable function .

  • The two variable functions .

Then it is shown in (exact, , Section 6.2) that the minimum quantum exact quantum query complexity of any Boolean function with or more influencing variables is . This essentially implies that the work of  oneQ is in fact a direct corollary of exact .

i.1 Organization & Contribution

In Section II, we start by describing the fact that the maximum number of influencing variables that a function with deterministic query complexity can have is . We first construct such a function using the decision tree model. The decision tree representation of such a function is a -depth fully-complete binary tree in which every internal node queries a unique variable. We first prove in Theorem 1 that any function with influencing variables and deterministic query complexity must have the same exact quantum query complexity ().

Next, we define a special class of Boolean functions in Section II.1, called the “Query Friendly” functions. A function with influencing variables is called query friendly if there does not exist any other function with influencing variables with lesser deterministic query complexity than . If lies between and (both inclusive) then all functions with deterministic query complexity are called query friendly functions. The proof in Theorem 1 directly implies that all query friendly functions with influencing variables are non-separable.

Then in Section II.2 we identify a class of non-separable query friendly functions for all values of . We conclude this section by showing that all query friendly functions with influencing variables are non-separable as well.

In Section III, we describe the parity decision tree model. We first discuss the simple result that a -depth parity decision tree can describe functions with upto influencing variables. In Section III.1 we define another set of query friendly functions on influencing variables that exhibit minimum separation (i.e., one) between deterministic and exact quantum query complexity for certain generalized values of . We prove by construction that if then there exists a class of query friendly functions such that for any function in that class we have . One should observe that although we prove this separation for a particular function for any , this implicitly proves separation for a class of Boolean functions, as reemphasized in Remark 1. We conclude the section by showing that for other values of there does not exist separable query friendly functions that can be completely described by the parity decision tree model.

Next in Section IV we study the Maiorana McFarland (M-M) type Bent functions, which is a cryptographically important class of Boolean Functions. This class is interesting as the algebraic degree of functions of this class defined on variables vary between and . First we observe that the deterministic query complexity of any function of this type on variable is . We further observe that the parity decision tree method can be used to form a simple algorithm that needs queries for any function in this class. We conclude this section by describing the real polynomial that describes any function belonging to this class, which gives us a lower bound of for the exact quantum query complexity of any function belonging to this class.

We conclude the paper in Section V outlining the future direction of our work. We further state open problems that we have encountered in this work. Solution to these problems will help us understand the limitations of the parity decision tree model as well as get possibly more optimal quantum algorithms for different classes of M-M functions.

Ii Decision Trees and No-separation results

As we have discussed, query algorithms can be expressed as decision trees in the classical deterministic model. In this regard, let us present the two following simple technical results. These results are well known in folklore and we present them for completeness.

Lemma 1.

There exists a Boolean function with influencing variables such that .

Proof.

We construct this function for any as follows. We know that if a Boolean function can be expressed as a decision tree of depth , then . We now build a decision tree, which is a fully-complete binary tree of depth . Each of the internal nodes in this tree is a unique variable, that is, no variable appears in the decision tree more than once. Since there are internal nodes in such a tree, this decision tree represents a Boolean function on variables with .

Without loss of generality we can name the root variable of the corresponding decision tree as and label the variables from left to right at each level in ascending order. The resultant structure of the tree is shown in Figure 3. ∎

Figure 3: Decision Tree corresponding to function with maximum influencing variables for

Having constructed such a Boolean function , we now show that is indeed the function with the maximum number of influencing variables that can be evaluated using the deterministic computational model using queries.

Lemma 2.

Given any integer , the maximum number of influencing variables that a Boolean function has such that is .

Proof.

Suppose there exists a Boolean function with influencing variables that can be evaluated using queries. This implies that there exists a corresponding decision tree of depth that expresses this function. However, in a decision tree corresponding to a Boolean function , all the influencing variables should be present as an internal node at least once in the decision tree. Otherwise,

which implies that is not an influencing variable of the function. Since there cannot exist a decision tree of depth that has more than internal nodes, such a function can not exist.

This implies that for any function with influencing variables and , the corresponding decision tree is a -depth complete tree where every variable is queried only once. ∎

It immediately follows that a function with influencing variables has deterministic query complexity .

Theorem 1.

Given any Boolean function with influencing variables and we have .

Proof.

This is proven by showing that any function characterized as above is at least as hard to evaluate as the function , which is AND of variables.

Given such a function , there exists a corresponding -depth complete tree . As we have shown in Lemma 2, in such a tree all internal nodes will query a variable and all the variables will appear in the tree exactly once.

Given the decision tree corresponding to let be a root to internal node path in the tree so that children of are the leaf nodes. Here

We call this set of variables . We fix the values of the variables as follows. Each of the variables at a level less than or equal to is assigned either or . Now either or .

  • In the first case, If a variable is at the -th level, i.e., its children are the leaf nodes then each such variable is fixed at the value such that . Then the function is reduced to .

  • In the second case, the values of variables in the -th level is fixed at the value so that . Then the function is reduced to .

The reduced function is in the first case and in the second case. In both the cases we have , as  (ANDk, , Table 1). We also know that for any Boolean function and therefore . Combining the two we get . ∎

We reiterate the idea behind the proof to further simplify the argument. Reducing a function to essentially implies that there exists a set of variables , such that if they are not all equal to , then the function outputs . In terms of the tree the implication is as follows. Let the path in the proof of Theorem 1 be such that the function is reduced to by fixing values of the other variables. Then while the decision tree is traversed from the root, if any of these variable’s value is , we move to a node that is out of the path, and then the value of the other internal nodes should be so fixed that we always reach a -valued leaf node.

ii.1 Query Friendly Functions

Having established these results, we characterize a special class of Boolean functions. Given any , We call the Boolean functions with influencing variables that have minimum deterministic query complexity as the query friendly functions on variables. We denote the corresponding query complexity of this class of functions as , and its value is calculated as follows.

Lemma 3.

The value of is equal to .

Proof.

We consider any such that . We have shown in lemma 2 that there cannot exist a Boolean function with variables that can be evaluated with classical queries.

Since the maximum number of influencing variables that a Boolean function with query complexity has is as proven above, there exists a Boolean function with variables with . Now , which concludes the proof. ∎

Corollary 1.

For , there does not exist any separable query friendly functions.

Proof.

For , we have . We have shown in Theorem  1 that any function with influencing variables and has . ∎

Now let us provide some examples of such functions where the deterministic classical and exact quantum query complexities are equal.

  • : the function is .

  • : the function is .

Next we move to a generalization when .

ii.2 Extending the result for

We first identify a generic set of non-separable query friendly functions where and then show that no query friendly function on  influencing variables are separable. We define such a set of non-separable query friendly functions for using the decision tree model again. We construct a decision tree of depth such that the first levels are completely filled and every variable occurs exactly once in the decision tree. That implies there are nodes in the -th level. Let us denote the corresponding function as .

Theorem 2.

The Boolean function on influencing variables has .

Proof.

This -depth decision tree constructed for any such that has the following properties.

  • The corresponding function has deterministic query complexity equal to . This is because the number of influencing variables in the function is more than the number of variables that a Boolean function with deterministic query complexity can have.

  • There is at least one internal node at -th level. let that node be called . Let the root to path be such that and so on. Applying the reduction used in Theorem  1 the corresponding Boolean function can be reduced to the function which is isomorphic to . (Note that , i.e., the complement of .) This implies that . We also know , and therefore the exact quantum query complexity of the function is . Figure 4 gives an example of a function in .

Figure 4: Decision Tree corresponding to

The result is thus a generalization when , in identifying a class of functions where the separation between classical and quantum domain is not possible.

We now show that in fact for , all query friendly functions with variables are non-separable.

Theorem 3.

Let be a query friendly function on variables, such that . Then .

Proof.

There exists a decision tree of depth- that evaluates . Since has variables then can be of the following forms:

  1. has internal nodes and each of the nodes query a unique variable. Each tree of this type corresponds to a function of the type and therefore is non-separable.

  2. has internal nodes and there exists two nodes in the tree which query the same variable.

We analyze the different structures of corresponding to the second case. Let the root node queries a variable . Then the following cases can occur.

Case 1: Both the children of query the same variable .
Let the two nodes be represented by and We choose a -depth path such that . Let us assume for simplicity and . For all vertices on the level such that we fix the value of the variable to such that . This construction reduces the function to the function, implying . As we know , this implies .

Case 2: At most one of the children of query a variable that appears more than once in the decision tree.
In this case there exists a -depth path consisting of nodes querying such that each of these variables appear only once in the tree such that

.

Now let the variable that is queried twice be and the nodes querying the variable be denoted as and . If at most one of these nodes is in the -th level then we can simply follow the method of the first case to reduce the function into .

If both the node querying are in the -th level, then at least one of their parent nodes do not belong to the set . Let the variable being queried by that node be and it is parent of at-least . We fix the value of to be such that . Now we again fix all the value of the variables on the -th level except and in the same way as in case 1 to reduce the function to .

The function is isomorphic to the function and thus the proof is completed.

Iii Parity Decision Trees and Separation results

We now explore the parity decision tree model introduced in exact . This model is constructed using the fact that in the exact quantum query model, the value of can be evaluated using a single query.

A parity decision tree is similar to a deterministic decision tree. But while in a decision tree a query can only return the value of a variable , in a parity decision tree a query can return either the value of a variable or the parity of two variables . A parity decision tree represents a quantum algorithm in which the oracle is queried values of type and

. In fact in this case the work qubits can be measured after each query and reset to a default state.

Let be a Boolean function that can be expressed as a -depth decision tree in which every internal node either queries a variable or the parity of two variables, . We can then say that . Figure 5 gives an example of a parity decision tree.

Figure 5: Example of a parity decision tree

The corresponding Boolean function is , with deterministic query complexity and exact quantum query complexity .

A -depth parity decision tree can only evaluate a function of algebraic degree less than or equal to , whereas there may exist a Boolean function of degree higher than that can be evaluated using queries. Thus, although this model does not completely capture the power of the quantum query model, we use the generalized structure of this model to find separable query friendly functions for certain values of .

We say a parity decision tree completely describes a Boolean function if is a parity decision tree with the minimum depth (say ) among all parity decision trees that represent and is equal to .

Lemma 4.

Given any there exists a Boolean function with variables such that .

Proof.

This proof follows directly from the definition of parity decision trees and the proof of existence of a Boolean function with variables with . Again we construct a depth complete parity decision tree such that every internal node is a query of the form such that no variable appears twice in the tree. This tree represents a Boolean function of variables and inherently . This function can also be reduced to the function which implies . This implies . We skip the proof of reduction to avoid repetition.

This is also the maximum number of influencing variables that a function can have so that and can be completely described using parity decision trees. This can be proven in the same way as in lemma 2 and we do not repeat it for brevity. ∎

We now prove some observations related to separability for a broader class of functions and then explore separability in query friendly functions.

Theorem 4.

If for any , then there exists a Boolean function for which .

Proof.

Let for some natural number . In this case . However, there exist Boolean functions with influencing variables such that . We define a generic class of such functions using parity decision trees. Let . Then we can always construct a complete parity decision tree of depth with the following constraints:

  • Every variable appears only once in the tree.

  • internal nodes have query of the form . The rest of the internal nodes query the value of a single variable.

Since , which is the number of internal nodes in a complete parity decision tree of depth , such a function always exists. ∎

However, if for some , then there not does not exist any Boolean function that can be completely expressed using the parity decision trees such that . If then as well and there does not exist any Boolean function with variables that can be expressed using parity trees and has . This is true as we have already obtained that the Boolean function with maximum number of influencing variables and depth , that can be expressed using parity decision tree is (putting in place of in Lemma 4 above).

Moreover, there does not exist any Boolean function with influencing variable such that exact query complexity is less than , which is equal to . It is interesting to note that if for some there exists a Boolean function with then there exists separation for all . This can be easily proven with induction.

Lemma 5.

If there exists a function with influencing variables such that , then there exists a function with influencing variables such that for all .

Proof.

If there exists a function with the specified property then can be constructed as follows. . It is easy to see . Using this construction recursively yields a desired function for any . ∎

We complete the categorization by defining a generalized subclass of Query friendly Boolean functions. We define this subclass such that a function , belonging to this, has .

iii.1 Separable Query Friendly functions

We construct a generic function for this set of query friendly functions using parity decision trees for values of such that there exists . We first describe the construction using a parity decision tree and then prove the query complexity values of the function.

Let us construct a parity decision tree of depth in the following manner. The first levels are completely filled, with each internal node querying a single variable. All variable appears exactly once in this tree. Let these variables be termed . In the -th level, there are internal nodes, with each query being of the form . (In case

is odd, there is one node querying a single variable). Then if

there are internal nodes in -th level and if n= there are nodes in the -th level, resulting in a fully-complete binary tree of depth . We denote this generic function as .

Theorem 5.

The Boolean function on influencing variables has and

Proof.

If then . We first prove that . Since there exists a parity decision tree of depth ,

(1)

If we fix one of the variables of each query of type to zero then the reduced tree corresponds to a non-separable function shown in II.2 of depth ,that is the function can be reduced to . This implies

(2)

Combining (1) and (2) we get .

Now we show that by converting the parity decision tree to a deterministic decision tree of depth . All the internal nodes of the parity decision tree from level to level queries a single variable. The nodes in the -th level have queries of the form . Each such node can be replaced by a deterministic tree of of depth in the following way. Suppose there is a internal node in the -th level.

We replace this node with a tree, whose root is . Both the children of the node queries and the leaf node values are swapped in the two subtrees. Without loss of generality, suppose in the original tree and Then in the root node and and so on. Figure 6 gives a pictorial representation of the transformation. The resultant deterministic decision tree is of depth as there is at least node in the -th level in the parity decision tree which goes through transformation. This implies . We also know that in this case . Combining the two results we get . ∎

Figure 6: Conversion of a node in the parity decision tree to a deterministic decision tree
Remark 1.

It should be noted that although we use a particular function for any to show the separation for and , this immediately means that this separation is established for at least the class of functions on influencing variables that are PNP equivalent to .

Let us now consider a function of the form described by its ANF as below:

This provides an example for , and . In Figure 8 we present the decision tree for this function and the corresponding quantum circuit is provided in Figure 9.

Figure 7: Parity Decision Tree corresponding to
Figure 8: Classical Decision Tree corresponding to
Figure 9: Quantum algorithm responding to

We now explain for the sake of completeness the difference in working of the exact quantum and deterministic algorithm for this function.

Suppose we want to evaluate this function at the point . The deterministic algorithm will first query , and getting its value as it will then query . Since is it will query the node which is it’s left children and then output as is .

The quantum algorithm will evaluate as follows.

  1. Here .

  2. The first X gate transforms it into

    Here implies where is the binary representation of integer .

  3. Then we get .

  4. The CNOT gates, the not gate and the Hadamard gates ( and ) transform the state into where .

  5. Now

    Let this state be .

  6. since and we get which is equal to . Measuring the third qubit in computational basis we get the desired output, .

This completes the example of separation.

Finally, we conclude this section by proving that our construction of separable query friendly function indeed finds such examples for all cases where a parity decision tree can compute such a function. This completes the characterization using parity decision trees.

Theorem 6.

If , there does not exist any separable query friendly function that can be completely described using parity decision trees.

Proof.

Let be a query friendly function on influencing variables. In this case , and hence . Therefore there exists a corresponding -depth decision tree . As we know there are at most internal nodes in such a tree and at least variables that needs to be queried at least once. Therefore there can be at most internal nodes which query variables that appear more than once in the tree.

This implies that there exists a node in the -th level querying a variable such that it appears only once in the decision tree. We consider the root() to path. It is to be noted that the root variable needs to be queried only once in any optimal tree. Let us also assume for simplicity that and

Let us now define the following sets of variables:

Let be functions with influencing variables belonging from the sets respectively. Then the ANF of can be described as:

This is because the variable can influence the function if and only if . This is due to the fact that is queried only once in the decision tree. Similarly,

and so on. Finally we have

Therefore, the function can be written as

This, in turn, implies that the resultant ANF contains a -term monomial , which implies .

It has been shown in (exact, , 3.1) that the minimum depth of any parity decision tree completely describing is at equal to or greater than , which implies there does not exist any query friendly function that can be completely described with a parity decision tree of depth . This concludes our proof. ∎

With this proof of limitation we conclude the study of Query friendly functions in this paper. Next we study the deterministic and exact quantum query complexity of a large class of Boolean functions.

Iv Maiorana McFarland Bent Functions

In this section we observe how parity decision trees can give us separation in a large class of Cryptographically important Boolean functions. We consider the Maiorana-McFarland (M-M) type Boolean functions MM1 , defined as follows.

Definition.

Given any positive integer a Boolean function of M-M class on variables is defined as

where

  1. represents the variables and represents the variables .

  2. is any Boolean function and is any map .

  3. is defined as the linear function .

If we set and define to be a bijective mapping, all resultant M-M functions are bent functions Bent1 , which are functions with highest possible nonlinearity for a given even . The non linearity of a function is defined as the minimum hamming distance of the truth table of a function of variable from all the linear function truth tables on variables cite MM1 . The M-M Bent functions and its different modifications have extensive applications in cryptographic primitives and in coding theory  Bentn2 .

We denote this class of M-M Bent functions by . There are functions in this class and the algebraic degree of the functions in this class vary between and . It is important to note that many functions of this class are not PNP equivalent, as two functions with different algebraic degree can not be PNP equivalent. At the same time it is also not necessary for two functions in with same algebraic degree to be PNP equivalent. For an example, let us consider the functions corresponding to the identity permutation map, i.e. . Then the function is of the form . Now let there be two functions such that that the function defined on are not PNP equivalent. Then the two functions are not PNP equivalent as well.

Having discussed the diversity of this class, we now analyze how the underlying definition of this class can lead to the same bounds for all the functions belonging to this class, and we use parity decision tree to achieve these bounds.

iv.1 Deterministic and Exact Quantum Query Complexity

We first calculate the deterministic query complexity of any function in the . Given a point we define the point as follows.