The (Sub/Sup) Majority Learning

Take a bitstring a, and an integer $\theta$. The oracle will respond 0 if $d(a,x)\leq \theta$  if queried with x and 1 otherwise. In other terms this oracle reply yes if two bitstrings agree on at least $\theta$ bit.

Here are the probability with a simple membership oracle (used with the usual phase kickback trick). Only even n gives an invertible matrix for the use of impatient learning.

For all these value, the optimum is achieved when the phase kickback takes value in {-1 ; 1}.

The majority problem is equivalent to the perceptron learning. For each $a \in \mathbb{Z}_n$ define a function $m_a : \mathbb{Z}_2^N \rightarrow \mathbb{Z}_2$ :

$m_a(x)= \begin{cases} 1 & \text{ if } wt(a-x)\leq n/2 \\0 & \text{ otherwise } \end{cases}$

Where wt is the weight of a bit-string (number of 1).

Alternatively we can write : $m_a(x) = \Theta (n/2 - wt(x-a) )$.

The problem is : determine a given an access to answers from $m_a$.

We saw in the presentation (link available soon) that the classical complexity was $O(n)$ while the quantum complexity was $O(\sqrt{n})$. In the following we show the classical bound.

The classical algorithm

For the classical case we will use a dichotomic process as in the binary chop. Here is the algorithm :

• At the first step you look the result for 0...0. If it's 1 you take all the possible weights that could have the same result ($2^n / 2 = 2^{n-1}$ weights possible). If it's 0 you take the complementary set of bits (the same number of weights if n is even).
• After that, you choose a new vector in your possible set, with the biggest Hamming distance with the previous tested bit. Then you look the result. After that step you would be able to remove another time : $2^{n-1} / 2$ remaining weights .
• ... you repeat these steps n-1 times at all, in the end you have $2^n/2^{n-1} = 2$ possible states.
• In the end, you may have two bits that you will separate by choosing a special bit b.  This bit b will depend on the two possible states and differentiate them.
• And you are done in n steps.

Example for n=3

For n=3, let's take the example of the following target bit : w = 001.

• I first try 000. I get 1. So the possible weights are : 000 / 001 / 010 / 100
• Then I test 001. I get 1. So the remaining states are 001 / 000 ( 011 / 101 are not possible because they are not in the previous set)
• Finally I test 101. I get 1. So the only possible result is 001.

Here is a list of the ones I found interesting to read :

First a general definition of the context :  Jorge Castro -  How Many Query Superpositions Are Needed to Learn?

A  paper about lots of bounds : Rocco Servedio & Steven Gortler - Equivalences and separations between quantum and classical learnability

Chapter 6 of Ashley Montanaro - Structure randomness ...

A recent paper that tries to avoid quantum oracle queries : Alp Atici & Rocco Servedio - Quantum algorithms for learning and testing juntas

And finally a well-known chapter about technics for computing quantum complexities : Ethan Bernstein, Umesh Vazirani - Quantum complexity theory

$i\hbar\frac{\partial}{\partial t}\left|\Psi(t)\right>=H\left|\Psi(t)\right>$

Vous pouvez aussi normalement écrire vos formules dans les commentaires en utilisant la syntaxe

Vous pouvez essayer ci-dessous, dans la mesure du raisonnable.
____________________________

English version :

You can now add Latex equations on my blog/comments. The correct syntax is