0

We consider  a quantum circuit that takes as input two vectors $\vert x \rangle$  and $\vert y \rangle$. The output of this quantum circuit must contain the reflected vector of   $\vert y \rangle$  with respect to  $\vert x \rangle$  (and whatever else that is irrelevant to the purpose ). It can be proved that this operator is nonlinear in the first argument, and in general is not unitary.  So no chances of implementing this operator with a quantum circuit, in complete generality.

However, In the reference linked in my question Programmable quantum gate arrays it is proved that a deterministic programmable gate array must have as many Hilbert dimensions in the program register as programs are implemented (consequence of the orthogonality requirement of the program states). If each program is given as input on n qubits, then n programs would require the array to have $n^2$ qubits in the program register, but in principle possible. In our case $\vert x \rangle$ is the program, the reflection axis. So we can implement all the operators $U_{\xi_k}$ described below  for $k=1.2.3......n$

And that means that these operators allow an implementation (with one quantum circuit with $n^2$  input "program" qubits ) as long as the program states are orthogonal (as explained above ). 

And that means that the Grover-Sysoev algorithm can be implemented. This consists in the following $n$ steps: $$|\xi_1\rangle = U_s U_\omega |s\rangle, \quad \vert \xi_2 \rangle = U_{\xi_1} U_\omega \vert s \rangle, \quad \cdots \quad \vert \xi_n \rangle = U_{\xi_{n-1}} U_\omega \vert s \rangle, $$ where $U_\omega\equiv I - 2  (\vert\omega\rangle\langle\omega \vert )$ and $U_s \equiv 2\vert s \rangle \langle s \vert - I$.

This algorithm finds a solution exponentially faster than Grover's. In other words, for a fixed large $n$ we can actually build this complex quantum circuit that would solve problems of practical interest efficiently.

The difference between this and the original Grover algorithm is that we perform an inversion about the previous state vector of the algorithm, rather than about the mean, at each step.

Note that the optimality proof in Grover 's original paper doesn't include operators with "program"  registers as input. 

Question  1. Is this algorithm  possible to implement,  in principle?

Question 2. Is this algorithm exponentially faster that Grover, for a fixed, chosen n?

The way "exponentially faster" is defined implies considering arbitrarily large values of n, but the meaning of this question is clear from the context.

My calculations indicate that both questions allow "yes" answers, but I could be wrong.

Another related question I asked previously can be found here.

glS
  • 24,708
  • 5
  • 34
  • 108
Cristian Dumitrescu
  • 325
  • 2
  • 8
  • I am interested in a quantum system that can solve efficiently NP complete problems for a large fixed n (practical interest), not in a universal quantum computer. – Cristian Dumitrescu May 19 '20 at 13:40
  • 1
    There are 2 main difficulties I have in understanding this question - the first is that the answer to 'related question 2' is that this algorithm is impossible, so you can't speed something up using something that's not possible. The second difficulty in understanding this is that you're asking about a speed-up for a fixed n - this is confusing as the complexity is generally defined in terms of n, (e.g. exponential algorithm is $O(e^n)$ - if you have an 'exponential speed-up', this becomes polynomial), so if you set n to be constant, the complexity is constant, so speed-up is impossible – Mithrandir24601 May 19 '20 at 23:36
  • a general comment: to maximise your chances of getting good answers, you should have your questions as specific and laser-focused as possible. A good rule of thumb is: can you come out with a title that actually describes the question you are asking? If not, that's a red flag. Another big red flag is that you are explicitly asking more than one question. Each post should contain one and only one question. – glS May 19 '20 at 23:48
  • I edited the question in an effort to make it clearer. If you don't agree with some of the edits feel free to revert it. Still, I don't quite understand why you think the impossibility proof in the linked answer doesn't rule out the algorithm altogether. It's also unclear how the algorithm works. You are applying different unitaries to the same state $|s\rangle$? I guess there is a typo somewhere? – glS May 20 '20 at 00:04
  • The quantum circuit C will have a data register with n qubits and a program register with $n^2$ qubits, so it can implement all the operators $U_{\xi_k}$ , the inversion about $\xi_k$. Let's consider  the relation $\vert \xi_k \rangle = U_{\xi_{k-1}} U_\omega \vert s \rangle $.  Then $U_\omega$ performs the phase inversion and passes the resulting vector    $U_\omega \vert s \rangle$   to  C in its data register. – Cristian Dumitrescu May 20 '20 at 06:28
  • Also the "program " $\xi_{k-1}$ (from the previous iteration ) is passed to C in its n corresponding distinct  qubits of the program register (each $\xi_i$ will have its assigned distinct n qubits among the $n^2$ qubits of the program register ).  Then C performs the inversion about  $\xi_{k-1}$  of the data vector and passes the result to the next iteration (as the program vector for the next iteration ). – Cristian Dumitrescu May 20 '20 at 06:34
  • The type of  algorithms in Grover's optimality proof have the form $U(\omega, t) = U_t U_\omega  U_{t-1}  U_\omega U_{t-2}.......U_1 U_\omega$ (an algorithm with t calls to $U_\omega$) . Then he considers vectors of the form $\vert \phi_t \rangle = U_t U_{t-1} U_{t-2}.......U_1 \vert \psi_0 \rangle$ and studies their properties.  You cannot do that here, because our operators need vectors in their program registers, which are not known ahead of time. – Cristian Dumitrescu May 20 '20 at 06:37
  • Thank you for your help @glS I appreciate it. I hope my four comments above answer your questions in a satisfactory manner. I am sure there is room for improvement, and you can probably find a better way, but these would be the general ideas in principle. Please feel free to correct and edit my question any way you find necessary. – Cristian Dumitrescu May 20 '20 at 06:43
  • I will consider an example @Mithrandir24601 in order to explain what I mean. With 1000 qubits you would need about $2^{500}$ Grover iterations in a search. With this algorithm you would need about 1000. That's the difference between not solving or solving quite a lot of practical problems of interest. The cost is that you would need a quantum circuit with one million program register qubits, or 1000 quantum circuits with 1000 program register qubits each. – Cristian Dumitrescu May 20 '20 at 06:58
  • I don't think I can have iterations of the type   $\vert \xi_k \rangle = U_{\xi_{k-1}} U_\omega \vert \xi_{k-1} \rangle$  (which would be faster indeed @glS ) because then $\xi_{k-1}$  must be involved  both in the data and program register, and these are unknown states, I cannot clone them (in contrast with the state $\vert s \rangle$     ). This probably requires more thinking. – Cristian Dumitrescu May 20 '20 at 07:03
  • If you keep the states in the program register orthogonal, then you have unitarity @Mithrandir24601, as defined for that subset of input. – Cristian Dumitrescu May 20 '20 at 07:13
  • "With 1000 qubits you would need about $2^{500}$ Grover iterations in a search. With this algorithm you would need about 1000" - this is either another way of saying 'you've gone from $O(e^n)$ to $O(n)$' (exactly what you've asked in the other question) or 'you've obtained a constant (albeit practically good) speed-up'. While this sounds practically great, this operation isn't unitary, so it's going to require postselection (if it's even possible then), which immediately puts it in a much worse complexity class and you've immediately added a factor of $O(e^n)$ or similar. – Mithrandir24601 May 20 '20 at 07:43
  • Also... An operator being unitary or not doesn't depend on the input state. If it does, you've got a nonlinear operator, so an invalid one – Mithrandir24601 May 20 '20 at 07:46
  • Yes you are correct , strictly from definitions. Reflections are unitary operations thought, and if you restrict yourself to a finite orthogonal subset of program vectors (reflection axes), I think this allows implementation. You get into nonlinearity only in the general case. In fact, when you are only selecting orthogonal subsets as program vectors, even the operations defining the Hilbert space in which you work are not closed, so there is no point to refer to nonlinearity in this case as a counter argument against a possible implementation. Thank you @Mithrandir24601 – Cristian Dumitrescu May 20 '20 at 08:11
  • I am not sure whether I am right, that's why I asked the question, but from the paper linked in my question " Programmable quantum gate arrays ", I understand that if you restrict yourself to a finite orthogonal set of program states, then you can build the implementation. You could be right @Mithrandir24601 I could have missed something. Thanks anyway. – Cristian Dumitrescu May 20 '20 at 08:50
  • Basically, the essence of the problem is this. You are basically saying that the finite number of orthogonal program states (in the case of programmable quantum gate arrays with program states passed as arguments ) must be known states. I am saying that they can be unknown states, as long as they are generated at previous steps of the algorithm, that''s it in a nutshell. Thanks for helping me identify the issue, maybe I will follow up with a more concrete question @Mithrandir24601 . – Cristian Dumitrescu May 20 '20 at 14:46
  • I am currently looking into a different approach @Mithrandir24601 https://quantumcomputing.stackexchange.com/q/12143/10110 Same objective, efficiently solving NP complete problems. Feedback appreciated, and please be as strict and critical as possible, I appreciate that. – Cristian Dumitrescu May 23 '20 at 17:26

0 Answers0