The best I have it's this generic answer, which I put here for clarity, hoping for improvements/corrections or even to be superseded by something better:
+ +++",1847,,,,,5/13/2018 5:23,,,,0,,,,CC BY-SA 4.0 +2038,2,,2036,5/13/2018 5:23,,16,,"If the limiting factor for fidelity in a given architecture+algorithm are the single-qubit gates, or the two-qubit gates, or the measurement, and if this limiting factor is not optimized in a ZEFOZ point, then effectively quantum fidelity will not be optimal in the ZEFOZ point.
+
Even if you only limit yourself to special-unitary operations, states will still accumulate global phase. For example, $Z = \begin{bmatrix} i & 0 \\ 0 & -i \end{bmatrix}$ is special-unitary but $Z \cdot |0\rangle = i |0\rangle \neq |0\rangle$.
+ +If states are going to accumulate unobservable global phase anyways, what benefit do we get out of limiting ourselves to special unitary operations?
+ +++ +are there any differences in the physical implementation of a unitary $U$ (mathematical matrix) and $V :=e^{i\alpha}U$, say in terms of some elementary gates?
+
As long you're not doing anything that could make the global phases relevant, they can have the same implementation. But if you're going to do something like, uh-
+ +++ +add controls to the elementary gates
+
Yeah, like that. If you do stuff like that, then you can't ignore global phases. Controls turn global phases into relative phases. If you want to completely ignore global phase, you can't have a black box ""add a control"" operation modifier.
+",119,,,,,5/13/2018 5:23,,,,2,,,,CC BY-SA 4.0 +2039,2,,2030,5/13/2018 9:44,,17,,"The first thing to do is to think topologically: make sure you understand why a coffee cup is the same thing topologically as a donut.
+ +Now, imagine we swap two identical particles, and do it again, so that we are back where we started. Apply this topological thinking to the paths taken by the particles: it is the same as doing nothing.
+ +Here I show a picture of this, where one particle is dragged around another particle. Topologically, the path taken can be deformed back to the ""do nothing"" path.
+ +The square root of this operation is a swap:
+ +Since the square root of 1 is either +1 or -1, a swap affects the state by multiplying by either +1 (for bosons) or -1 (for fermions.)
+ +To understand anyons, we are going to do the same analysis, but with one less dimension. So now a particle winding around another particle is not topologically the same as the ""do nothing"" operation:
+ +We need the extra third dimension to untangle the path of the anyon, and since we can't do this topologically, the state of the system could be modified by such a process.
+ +Things get more interesting as we add particles. With three anyons, the paths taken can get tangled, or braided in arbitrary ways. To see how this works it helps to use three dimensions: two space dimensions and one time dimension. Here is an example of three anyons wandering around and then returning back where they started:
+ +Long before physicists started to think about anyons, the mathematicians already worked out how these braiding processes combine to form new braids or undo braids. These are known as ""braid groups"" in work that dates back to Emil Artin in 1947.
+ +Like the distinction between Bosons and Fermions above, different anyon systems will behave differently when you do these braid operations. One example of anyon, known as the Fibonacci anyon, are able to approximate any quantum operation just by doing these kinds of braids. And so theoretically we could use these to build a quantum computer.
+ +I wrote an introductory paper on anyons, which is where I got these pictures from: https://arxiv.org/abs/1610.05384. There's more mathematics there, as well as a description of a close cousin of anyon theory known as a ""modular functor"".
+ +Here is another good reference, with more Fibonacci anyon goodness: Introduction to topological quantum computation with non-Abelian anyons +
+ +EDIT: I see that I didn't say anything about the observables. +The observables of the system measure the total anyon content within a region. In terms of anyon paths we can think of this as bringing all the anyons in some region together and ""fusing"" them into one anyon, which may be the ""no anyon"" aka vacuum state. For a system supporting Fibonacci anyons there will only ever be two outcomes for such a measurement: fibonacci anyon or vacuum. Another example is the toric code where there are four anyon outcomes.
+",263,,263,,5/15/2018 10:11,5/15/2018 10:11,,,,2,,,,CC BY-SA 4.0 +2040,2,,2036,5/13/2018 13:33,,13,,"The fact that quantum gates are unitary, is rooted in the fact that the evolution of (closed) quantum systems is by the Schrödiner equation. For a time interval in which we are trying to realise a particular unitary transformation at a constant rate, we use the time-independent Schrödinger equation:
+ +$$ \tfrac{\mathrm d}{\mathrm dt} \lvert \psi(t) \rangle = \tfrac {1}{i\hbar}H \lvert \psi(t) \rangle, $$
+ +where $H$ is the Hamiltonian of the system: a Hermitian matrix, whose eigenvalues describe energy eigenvalues. In particular, the eigenvalues of $H $ are real. The solution to this equation is
+ +$$ \lvert \psi(t) \rangle = \exp\bigl(-i H t/\hbar\bigr) \lvert \psi(0) \rangle $$ +where $U = \exp(-iHt/\hbar)$ is the matrix which you obtain by taking the eigenvectors of $H$, and replacing their eigenvalues $E$ with $\mathrm{e}^{iEt/\hbar}$. Thus, from a matrix with real eigenvalues, we get a matrix whose eigenvalues are complex numbers with unit norm.
+ +What would it take for this evolution to specifically be a special unitary matrix? A special unitary matrix is one whose determinant is precisely $1$; that is, whose eigenvalues all multiply to $1$. This corresponds to the restriction that the eigenvalues of $H$ all sum to zero. Furthermore, because the eigenvalues of $H$ are energy levels, whether the sum of its eigenvalues is equal to zero depends on how you have decided to fix what your zero energy point is — which is in effect a subjective choice of reference frame. (In particular, if you decide to adopt the convention that all of your energy levels are non-negative, this implies that no interesting system will ever have the property of the energy eigenvalues summing to zero.)
+ +In short, gates are unitary rather than special unitary, because the determinant of a gate does not correspond to physically meaningful properties — in the explicit sense that the gate arises from the physics, and the conditions which correspond to the determinant of the gate being 1 is a condition of one's own reference frame and not the physical dynamics.
+",124,,124,,5/13/2018 14:38,5/13/2018 14:38,,,,0,,,,CC BY-SA 4.0 +2041,1,2042,,5/13/2018 14:09,,10,639,"Question: Given a unitary matrix acting on $n$ qubits, can we find the shortest sequence of Clifford + T gates that correspond to that unitary?
+ +For background on the question, two important references:
+ +-
+
- Fast and efficient exact synthesis of single qubit unitaries generated by Clifford and T gates by Kliuchnikov, Maslov, and Mosca +
- Exact synthesis of multiqubit Clifford+T circuits by Giles and Selinger. +
Getting an optimal decomposition is definitely an open problem. (And, of course, the decomposition is intractable, $\exp(n)$ gates for large $n$.) A ""simpler"" question you might ask first is what is the shortest sequence of cnots and single qubit rotations by any angle, (what IBM, Rigetti, and soon Google currently offer, this universal basis of gates can be expressed in terms of your basis of Cliffords and t-gates). This ""simpler"" question is also open and has a non-unique answer. A related question is what is an exact optimal decomposition of gates from a universal basis to go from ground state to a given final state.
+ +I am assuming you are referring to exact decompositions. If you want approximate decompositions, there are different methods for that, such as the Trotter-Suzuki decomposition, or approximating an exact decomposition.
+ +The ""quantum csd compiler"" in Qubiter does a non-optimized decomposition of any n qubit unitary into cnots and single qubit rots using the famous csd (Cosine-Sine Decomposition) subroutine from LAPACK. Some enterprising person could try to find optimizations for Qubiter's quantum compiler. You can use Qubiter's compiler, for example (I wrote a paper on this), to let your classical computer re-discover Coppersmith's quantum Fourier Transform decomposition!
+ +Qubiter is open source and available at github (full disclosure - I wrote it).
+",1974,,91,,08-07-2018 21:07,08-07-2018 21:07,,,,1,,,,CC BY-SA 4.0 +2043,1,2044,,5/13/2018 15:17,,6,335,"-
+
Consider the state $|X\rangle = \sqrt{0.9} |00\rangle + \sqrt{0.1} |11\rangle$, shared between Alice and Bob, who are located far apart.
+Alice brings in an ancilla qubit at her location (left-most qubit in the kets): $|X\rangle = \sqrt{0.9} |000\rangle + \sqrt{0.1} |011\rangle$.
+Now Alice performs a CNOT gate with the control being her entangled qubit, and the target being the ancilla: $|X\rangle = \sqrt{0.9} |000\rangle + \sqrt{0.1} |111\rangle$.
+Then Alice measures the ancilla in the basis $\{\sqrt{0.1} |0\rangle + \sqrt{0.9} |1\rangle , \sqrt{0.9} |0\rangle - \sqrt{0.1} |1\rangle\}$. Supposing the measurement outcome is $+1$, i.e., the ancilla collapsed to the state $\sqrt{0.1} |0\rangle + \sqrt{0.9} |1\rangle$ , the remaining state of the initial $2$ qubits will be $|X\rangle = \sqrt{0.1 \times 0.9} |00\rangle + \sqrt{0.9 \times 0.1} |11\rangle$, which is the maximally entangled state up to a normalization factor.
+We started from a state that was not maximally entangled, and we were able to boost the entanglement by doing a local measurement and post-selecting on the outcome.
+
Is entanglement distillation using post-selection as I have described above feasible?
+",1860,,26,,5/13/2018 16:16,5/13/2018 17:27,Entanglement distillation by local operations and post-selection using one entanglement pair,There are two different contexts where the term ""entanglement distillation"" is used, and are largely incomparable, even if they are conceptually extremely close (and I'm sure you'll be able to find papers that blur these boundaries).
+ +In the first, Alice and Bob share a known quantum state which is (usually) a pure state. They use this to make a maximally entangled state with some probability. You can see this, for example, in section 12.5.1 of Nielsen & Chuang (""Transforming bi-partite pure state entanglement""). The protocol described in the question is the standard protocol in this context, except that the measurements are often expressed as POVMs instead of projective measurements in a larger Hilbert space.
+ +In the second, one has many copies of a mixed state that one wishes to to make more entangled. This situation may be referred to as ""purification"" because one of the aims is, essentially, to make the state as pure as possible. The use of the mixed state, as usual, may describe part of an entangled system, or may describe some lack of knowledge/stochastic preparation procedure etc. In essence, there is some lack of knowledge about what you have, and variation between the copies, and it is this extra complication that necessitates multiple copies. See, for example, section 12.5.3 of Nielsen & Chuang (""Entanglement distillation and quantum error-correction"").
+",1837,,,,,5/13/2018 17:27,,,,0,,,,CC BY-SA 4.0 +2045,2,,2036,5/14/2018 6:03,,5,,"When writing gates for, for example, a quantum circuit diagram, you could always write them using the convention of having determinant one (from the special unitary group), but it's just a convention. It makes no physical difference to the circuit that you implement. As said elsewhere, whether what you naturally produce corresponds directly to the special unitary is really a choice of convention, and where you define your 0 energy to be.
+ +As for the issue when you start implementing controlled-$U$, there is an interesting comparison to be made. Let's say we define $V=e^{i\alpha}$. How can we implement controlled-$V$ in terms of controlled-$U$? You apply controlled-$U$ and then, on the control qubit, you apply the phase gate $\left(\begin{array}{cc} 1 & 0 \\ 0 & e^{i\alpha} \end{array}\right)$. There are two things to observe here. First, the difference is on the control qubit rather than the target qubit. The target qubit, where you're implementing the $U$, doesn't really care about the difference in phase. It's the control-qubit that's hit by the phase gate. The second is that I didn't write the phase gate as a special unitary. Of course, I could have written it as $\left(\begin{array}{cc} e^{-i\alpha/2} & 0 \\ 0 & e^{i\alpha/2}\end{array}\right)$ but I didn't because the way that I chose to write it was notationally more convenient - less writing for me, and hopefully more immediately obvious to you why it works.
+",1837,,,,,5/14/2018 6:03,,,,0,,,,CC BY-SA 4.0 +2046,2,,2041,5/14/2018 7:46,,4,,"Suppose that an exact synthesis was possible for your provided unitary (the number of theoretic restriction on the entries) and so the algorithms described in the question gave you a sequence of Clifford+T gates that implemented that unitary. As stated in the Giles-Selinger paper, you get a sequence that is very far from optimal. So at this point you have reduced to the word problem in the group generated by the Clifford+T gate set. Some groups have algorithms to shorten a given word while still representing the same element of the group into a normal form that is the shortest within that class. Others do not.
+ +More details to illustrate the principle: Let us say there are $2$ qubits. Denote $S_1$ etc for the generator that does the phase gate on qubit $1$, $CNOT_{12}$ for $1$ being the control etc. Each one of these is treated as a letter. The algorithm will spit out some word in these generators. The group is the group with these generators and many relations like $S_i^4=1$ and $X_i Y_j = Y_j X_i$ when $i \neq j$ among many other relations. So this defines some finitely generated group. Because we have a word from the provided algorithms but has not been optimized, the task is to provide a convenient shortest possible normal form in the word problem for this group. So if given the word $S_1 S_1 S_2 S_1 S_1$ one could use the relation $S_1 S_2 = S_2 S_1$ twice and the $S_1^4=1$ relation once to get $S_2$ as a shorter word that represents the same group element. For a given group presentation, one would like an algorithm that takes an arbitrary word and reduces it. In general this is not possible.
+ +Disclaimer for below: Forthcoming project/Haskell implementation joint w/ Jon Aytac.
+ +I don't know about the solvability of the word problem for the Clifford+T gate set, but one can do something simpler with only the involutions (call them $r_i$) in that set and only the relations of the form $(r_i r_j)^{m_{ij}}=1$. That is a Coxeter group related to the Clifford+T gate set, but with an efficiently solvable word problem. So one may take the result of the Giles-Selinger algorithm and potentially shorten it using only these very simple relations (after looking at segments with only those involution letters). In fact any algorithm that takes a given unitary and approximates or exactly synthesizes it into Clifford+T can be fed into this procedure to potentially shorten it slightly.
+",434,,434,,5/15/2018 4:40,5/15/2018 4:40,,,,0,,,,CC BY-SA 4.0 +2047,1,2048,,5/14/2018 8:18,,9,919,"I understand that there are two ways to think about 'general quantum operators'.
+ +Way 1
+ +We can think of them as trace-preserving completely positive operators. These can be written in the form +$$\rho'=\sum_k A_k \rho A_k^\dagger \tag{1}$$ +where $A_k$ are called Kraus operators.
+ +Way 2
+ +As given in (An Introduction to Quantum Computing by Kaye, Laflamme and Mosca, 2010; pg59) we have a +$$\rho'=\mathrm{Tr}_B\left\{ U(\rho \otimes \left| 00\ldots 0\right>\left<00\ldots 0 \right|) U^\dagger \right\} \tag{2}$$ +where $U$ i s a unitary matrix and the ancilla $\left|00 \ldots 0\right>$ has at most size $N^2$.
+ +Question
+ +Exercise 3.5.7 (in Kaye, Laflamme and Mosca, 2010; pg60) gets you to prove that operators defined in (2) are completely positive and trace preserving (i.e. can be written as (1)). My question is the natural inverse of this; can we show that any completely positive, trace preserving map can be written as (2)? I.e. are (1) and (2) equivalent definitions of a 'general quantum operator'?
+",2015,,55,,5/31/2021 15:03,5/13/2022 8:49,Is the Kraus representation of a quantum channel equivalent to a unitary evolution in an enlarged space?,This question is posed, and answered positively, in Nielsen & Chuang in a subsection of chapter 8 entitled ""System-environment models for and operator-sum representation"". In my version, it can be found on page 365.
+ +Imagine $|\psi\rangle$ is an arbitrary pure state on the space upon which you wish to enact the operators. Let $|e_0\rangle$ be some fixed state on another quantum system (with dimension equal to at least the number of Krauss operators, and labelled 'B'). Then you can define a unitary by its action on the space of states spanned by $|\psi\rangle$: +$$ +U|\psi\rangle|e_0\rangle=\sum_k(A_k|\psi\rangle)|e_k\rangle, +$$ +where the $|e_k\rangle$ are an orthonormal basis. To check that this corresponds to a valid unitary, we just have to test it for different input states and ensure that the initial overlap is preserved: +$$ +\langle\psi|\phi\rangle\langle e_0|e_0\rangle=\langle\psi|\langle e_0|U^\dagger U|\phi\rangle|e_0\rangle=\langle\psi|\sum_kA_k^\dagger A_k|\phi\rangle, +$$ +which is true thanks to the completeness relation of the Krauss operators.
+ +Finally, one just has to check that this unitary does indeed implement the claimed map: +$$ +\text{Tr}_B\left(U|\psi\rangle\langle \psi|\otimes|e_0\rangle\langle e_0|U^\dagger\right)=\sum_kA_k|\psi\rangle\langle\psi|A_k^\dagger. +$$
+",1837,,,,,5/14/2018 8:59,,,,0,,,,CC BY-SA 4.0 +2049,1,,,5/14/2018 10:19,,13,927,"The feature of quantum error correcting codes called degeneracy is that they can sometimes be used to correct more errors than they can uniquely identify. It seems that codes exhibiting such characteristic are able to overcome the performance of quantum error correction codes that are nondegenerate.
+ +I am wondering if there exists some kind of measure, or classification method in order to determine how degenerate is a quantum code, and so if there has been any study trying to determine the error correction abilities of quantum codes depending on the degeneracy of them.
+ +Apart from that, it would be interesting to give reference or some intuition about how to construct good degenerate codes, or just reference about the current state of the art of those issues.
+",2371,,55,,11/30/2021 22:27,02-08-2022 21:49,Degeneracy of Quantum Error Correction Codes,I don't have a complete answer, but perhaps others can improve on this starting point.
+ +There are probably 3 things to ask about the code:
+ +-
+
How degenerate is it?
+How hard is it to perform the classical post-processing of the error syndrome in order to determine which corrections to make?
+What are its error correcting/fault-tolerant thresholds?
+
I suppose a simple enough measure of degeneracy is the extent to which the Quantum Hamming Bound is surpassed. For an $[[N,k,d]]$ code, a non-degenerate code must satisfy:
+ +$$2^{N-k}\geq\sum_{n=0}^{\lfloor d/2\rfloor}3^n\binom{N}{n}$$
+ +So the amount by which that bound is violated suggests something interesting about how densely the information is packed. Of course, that's no use if your mega-degenerate code cannot actually correct for any errors. Similarly, if your code is in principle awesome, but it takes too long to actually work out what the correction is, your code isn't really any use in practice because errors will continue to accumulate as you try to work out what corrections to do.
+",1837,,26,,5/14/2018 16:13,5/14/2018 16:13,,,,4,,,,CC BY-SA 4.0 +2051,1,2052,,5/14/2018 13:19,,7,147,"I submitted a job in the 0.5.0 version of QISKit using
+ +job = execute(qc, 'ibmqx5', shots=shots)
+This just submits the job, and does not wait for a result.
+ +I then immediately tested whether the job was still running using
+ +print(job.running)
+This gave the result False. However, when I requested the result using
job.result()
+This still took a while to get the result, suggesting that the job actually was still running after all. What is going on here?
+",409,,,,,5/14/2018 13:25,"Why does job.running in QISKit output False, even if the job is still running?",There are three stages that the job goes through, as you'll see if you also print the status using print(job.status).
The first is an initialization stage. This returns False for job.running, because it hasn't started running yet.
Then your job actually will run, and so give True for job.running. Finally it will have finished running, and so job.running goes back to False.
So don't use job.running to test whether a result is ready.
Plain and simple answer: In the absence of decoherence, state vectors evolve according to $|\psi(t)\rangle = e^{-iHt}|\psi(0)\rangle$ for a Hamiltonian $H$. This is what a ""gate"" is doing. Hamiltonians have to be Hermitian, so this transformation is unitary. Hamiltonians do not have to have eigenvalues that sum to 0, so the transformation does not have to be special unitary.
+",2293,,,,,5/14/2018 15:24,,,,0,,,,CC BY-SA 4.0 +2054,1,,,5/14/2018 18:37,,25,585,"In a comment on my answer to the question: What exactly are anyons and how are they relevant to topological quantum computing? I was asked to give specific examples of occurrence of anyons in nature. I've spent 3 days searching, but every article refers to either "proposed experiments" or "nearly definitive evidence".
+Abelian anyons:
+Fractional charges have been measured directly since 1995, but in my search, all articles pointing to evidence of fractional statistics or an exchange factor $e^{i\theta}\ne\pm1$, point to this nearly 7-year old pre-print, where they say in the abstract that they "confirm" detecting the theoretically predicted phase of $\theta =2\pi/3$ in the $\nu=7/3$ state of a quantum Hall system. However, the paper seems to have never passed a journal's peer review. There is no link to a journal DOI on arXiv. On Google Scholar I clicked "see all 5 versions", but all 5 were arXiv versions. I then suspected the article's name might have changed at the time of publication so went hunting for it on the authors' websites. The last author has Princeton University's Department of Electrical Engineering listed as affiliation, but does not show up on that department's list of people (after clicking on "People", I clicked on "Faculty", "Technical", "Graduate Students", "Administrative", and "Research Staff" but nothing showed up). The same happened for the second-last author! The third-last author does have a lab website with a publication list, but nothing like this paper appears in the "Selected Publications out of more than 800" page. The fourth-last author is at a different university, but his website's publication list is given as a link to his arXiv page (still no published version visible). The 5th last, 6th last, and 7th last authors have an affiliation of James Franck Institute and Department of Physics at the University of Chicago, but none of their three names shows up on either website's People pages. One of the authors also has affiliation at a university in Taiwan, and her website there lists publications co-authored with some of the people from the pre-print in question, but never anything with a similar title or with a similar enough author list. Interestingly, even her automatically generated but manually adjustable Google Scholar page does not have even the arXiv version but does have earlier papers (with completely different titles and no mention of anyons) with some of the co-authors. That covers all authors. No correspondence emails were made available.
+1. Is this pre-print the only claim of confirming an exchange factor $\ne\pm1$ ?
+2. If yes, what is wrong with their claimed confirmation of this? (It appears to have not passed any journal's peer review, and it also appears that an author has even taken down the arXiv version from her Google Scholar page).
Non-abelian anyons:
+I found here this quote: "Experimental evidence of non-abelian anyons, although not yet conclusive and currently contested [12] was presented in October 2013 [13]." The abstract of [12] says that the experiment in [13] is inconsistent with a plausible model and that the authors of [13] may have measured "Coulomb effects" rather than non-Abelian braiding. Interestingly the author list of [13] overlaps with the pre-print mentioned in the Abelian section of this question, though that pre-print was from 2 years earlier and said in the abstract "Our results provide compelling support for the existence of non-Abelian anyons" which is a much weaker statement than what they say in the same abstract for the Abelian case: "We confirm the Abelian anyonic braiding statistics in the $\nu=7/3$ FQH state through detection of the predicted statistical phase angle of $2\pi/3$, consistent with a change of the anyonic particle number by one."
+",2293,,2293,,7/20/2020 22:27,3/23/2022 16:03,What is the status of confirming the existence of anyons?,It depends what you mean by the 'existence' of anyons.
+ +One way is to engineer a Hamiltonian which leads to quasiparticles (or other defects) that have anyonic statistics. This will require the Hamiltonian to be implemented, the system to be cooled to sufficiently near the ground state, the anyons to be manipulated, etc. So there's a lot to be done, and I don’t think that the development of the systems required has a lot of other applications. So it suffers from being both hard to do, and quite a niche.
+ +Hopefully, someone else will give you the answers you want on this kind of approach. However, I thought it is important to note that there is another way to get anyons. This is to not bother with the Hamiltonian. Instead, the eigenstates can be prepared and manipulated directly.
+ +In this case, you aren’t getting any topological protection from the Hamiltonian. Instead, measurements are constantly made of what eigenstate you are in, in order to detect and help you mitigate the unwanted effects of errors.
+ +The most realistic examples of this approach will be ones for which these operations can be easily performed on a quantum computer. All the development and progress towards building qubits and their gates can then be directly used in the search for anyons.
+ +Anyons are systems that can be easily implemented with qubits or qubits are typically a specific form of quantum error correcting code. Specifically, they are stabilizer codes for which the states of the stabilizer space are topologically ordered, and syndrome measurements correspond to measuring whether anyons are present at each point throughout the system.
+ +Th simplest example is the surface code. The basic quasiparticles of this are Abelian anyon. There have been experiments that create and manipulate these anyons to demonstrate their braiding behaviour. The first example was done over a decade ago in photonics systems.
+ +The surface code can also host defects which behave as Majorana modes, and therefore non-Abelian anyons. I implemented a very minimal example of their braiding in this paper.
+ +As quantum processors get larger, cleaner and more sophisticated, there will be a lot more of this kind of study. I would think that the majority of the anyons that we will see and use will be realized in this manner, rather than with an implementation of the Hamiltonian.
+",409,,26,,5/15/2018 6:02,5/15/2018 6:02,,,,8,,,,CC BY-SA 4.0 +2056,1,11472,,5/15/2018 2:06,,11,320,"The recent McClean et al. paper Barren plateaus in quantum neural network training landscapes shows that for a wide class of reasonable parameterized quantum circuits, the probability that the gradient along any reasonable direction is non-zero to some fixed precision is exponentially small as a function of the number of qubits.
+ +This seems to affect Noisy Intermediate-Scale Quantum (NISQ) programs (as proposed by e.g. John Preskill) since they involve hybrid quantum-classical algorithms, ie training a parameterized quantum circuit with a classical optimization loop.
+
My question: How do you avoid getting stranded on those barren plateaus? Concretely, how would one go about building one's Ansatz Haar states to avoid getting stuck in those plateaus? The paper proposes but does not elaborate:
+ +++",2387,,26,,01-01-2019 10:15,04-09-2020 10:36,"Devising ""structured initial guesses"" for random parametrized quantum circuits to avoid getting stuck in a flat plateau",One approach to avoid these landscapes in the quantum setting is to + use structured initial guesses, such as those adopted in quantum + simulation.
+
I am currently trying to implement a boosting algorithm akin to XGBoost with a quantum device. The reason is that I want to make use of a quantum device to train weak classifiers. However, as far as I know, the current quantum device can only be used for binary variables including both input variables and outputs.
+ +Is it possible to use all binary variables to implement the additive training as it does in the XGBoost?
+ + +",2354,,26,,5/15/2018 6:26,10/25/2022 2:02,Gradient boosting akin to XGBoost using a quantum device,In the comments to a question I asked recently, there is a discussion between user1271772 and myself on positive operators.
+ +I know that for a positive trace-preserving operator $\Lambda$ (e.g. the partial transpose) if acting on a mixed state $\rho$ then although $\Lambda(\rho)$ is a valid density matrix it mucks up the density matrix of the system it is entangled to - hence this is not a valid operator.
+ +This and user1271772's comments, however, got me thinking. $\Lambda$ acting on a state which is not part of a larger system does indeed give a valid density matrix and there is no associated entangled system to muck it up.
+ +My question is, therefore: Is such an operation allowed (i.e. the action of a positive map on a state which is not part of a larger system). If not, why not? And if so, is it true that any positive map can be extended to a completely positive map (perhaps nontrivially)?
+",2015,,10480,,3/26/2021 4:43,3/26/2021 4:43,Is acting with a positive map on a state not part of a larger system allowed?,Long-range entanglement is characterized by topological order (some kinds of global entanglement properties), and the ""modern"" definition of topological order is the ground state of the system cannot be prepared by a constant-depth circuit from a product state, instead of ground states dependency and boundary excitations in traditional. Essentially, a quantum state which can be prepared by a constant-depth circuit is called trivial state.
+ +On the other hand, quantum states with long-range entanglement are ""robust"". One of the most famous corollaries of quantum PCP conjecture which proposed by Matt Hastings is the No Low-energy Trivial States conjecture, and the weaker case proved by Eldar and Harrow two years ago (i.e. NLETS theorem: https://arxiv.org/abs/1510.02082). Intuitively, the probability of a series of the random errors are exactly some log-depth quantum circuit are very small, so it makes sense that the entanglement here is ""robust"".
+ +It seems that this phenomenon is some kinds of similar to topological quantum computation. Topological quantum computation is robust for any local error since the quantum gate here is implemented by braiding operators which is connected to some global topological properties. However, it needs to point that ""robust entanglement"" in the NLTS conjecture setting only involved the amount of entanglement, so the quantum state itself maybe changed -- it does not deduce a quantum error-correction code from non-trivial states automatically.
+ +Definitely, long-range entanglement is related to homological quantum error-correction codes, such as the Toric code (it seems that it is related to abelian anyons). However, my question is that are there some connections between long-range entanglement (or ""robust entanglement"" in the NLTS conjecture setting) and topological quantum computation? +Perhaps there exists some conditions regarding when the correspondent Hamiltonian can deduce a quantum error-correction code.
+",1777,,1777,,5/22/2018 21:36,5/22/2018 21:36,Are there connections between long-range entanglement and topological quantum computation?,The quantum Hamming bound for a non-degenerate $[[N,k,d]]$ quantum error correction code is defined as:
+ +\begin{equation} +2^{N-k}\geq\sum_{n=0}^{\lfloor d/2\rfloor}3^n\begin{pmatrix}N \\ n\end{pmatrix}. +\end{equation} +However, there is no proof stating that degenerate codes should obey such bound. I wonder if there exists any example of a degenerate code violating the quantum Hamming bound, or if there have been some advances in proving similar bounds for degenerate codes.
+",2371,,55,,2/22/2021 15:59,2/22/2021 15:59,Violation of the Quantum Hamming bound,There were two simultaneous PRLs published by Kitaev & Preskill and Levin & Wen that I think answer your question.
+ +These use the area law of entanglement seen by states that can be expressed as ground states of a Hamiltonian with only local interactions.
+ +Specifically, suppose you have a 2D system of interacting particles in a pure state. You then single out some region, and calculate the von Neumann entropy of the reduced density matrix for that region. This will essentially be a measure of how entangled the region is with its complement. The area law tells us that this entropy, $S$, should obey
+ +$S = \alpha L - \gamma + \ldots$
+ +Here $L$ is the length of the perimeter of the region. The first term accounts for the fact that correlations in these systems are typically short range, and so the entanglement is mostly composed of correlations between particles on each side of the boundary.
+ +The $\gamma$ term is unaffected by the size or shape of the region, and so represents a contribution of global and topological effects. Whether this is non-zero, and what the value is, tells you about the topologically ordered nature of your entangled system.
+ +The $\ldots$ term just represents contributions that decay as the region increases, and so can be ignored as $L\rightarrow \infty$.
+ +The two papers, and ones based upon them, then find ways to isolate and calculate $\gamma$ for different entangled states. The value is shown to depend on the anyon model for which these entangled states represent the vacuum.
+",409,,,,,5/15/2018 9:29,,,,0,,,,CC BY-SA 4.0 +2062,1,2063,,5/15/2018 10:12,,5,1157,"To use certain things in QISKIt, such as acessing the real quantum processors, it seems that there is a file 'Qconfig.py'. That needs to be set up.
+ +How do I do this?
+",409,,,,,2/15/2019 14:58,What is Qconfig in QISKit and how do I set it up?,To get access to the real devices and remote simulators, you need to have an account with the IBM Q Experience. Once you do, you can get your API key from the account page.
+ +Once you have the API key, you can set up a Qconfig file. Let's assume that you want to run things from the QISKit tutorial. The Qconfig file can then be set up by editing the file located here.
+ +You just need to replace the line
+ +APItoken = None
+with
+ +APItoken = ""randomstringoflettersandnumbersyoucopiedfromthewebsite""
+Where the stuff within the quotation marks should be your actual API token.
+ +You also need to rename the file from 'Qconfig.py.template' to just Qconfig.py.
Now you need to import the information from this file in your programs. This will depend on where you program sits in your computer relative to the Qconfig file.
+ +If the .py or .ipynb file containing your program is sitting in the same directory as 'Qconfig.py', you can import with just
import Qconfig
+qx_config = {
+ ""APItoken"": Qconfig.APItoken,
+ ""url"": Qconfig.config['url']}
+except Exception as e: + print(e) + qx_config = { + ""APItoken"":""YOUR_TOKEN_HERE"", + ""url"":""https://quantumexperience.ng.bluemix.net/api""}
+ +and then register your connection to the API with
+ +register(qx_config['APItoken'], qx_config['url'])
+ +If your .py or .ipynb is one directory level down, such as for this you'll need to have the lines
import sys
+sys.path.append(""../"")
+before you try to import. This tells the program to look for the Qconfig file in the directory above instead.
+",409,,,,,5/15/2018 10:12,,,,0,,,,CC BY-SA 4.0 +2064,2,,2058,5/15/2018 10:49,,8,,"Any map which is not Completely Positive, Trace Preserving (CPTP), is not possible as an ""allowed operation"" (a more-or-less complete account of how some system transforms) in quantum mechanics, regardless of what states it is meant to act upon.
+ +The constraint of maps being CPTP comes from the physics itself. Physical transformations on closed systems are unitary, as a result of the Schrödinger equation. If we allow for the possibility to introduce auxiliary systems, or to ignore/lose auxiliary systems, we obtain a more general CPTP map, expressed in terms of a Stinespring dilation. Beyond this, we must consider maps which may occur only with a significant probability of failure (as with postselection). This is perhaps one way of describing an ""extension"" for non-CPTP maps to CPTP maps — engineering it so that it can be described as a provocative thing with some probability, and something uninteresting with possibly greater probability; or at least a mixture of a non-CPTP map with something else to yield a total evolution which is CPTP — but whether it is useful to do so in general is not clear to me.
+ +On a higher level — while we may consider entanglement a strange phenomenon, and in some way special to quantum mechanics, the laws of quantum mechanics themselves make no distinctions between entangled states and product states. There is no sense in which quantum mechanics is delicate or sensitive to the mere presence of nonlocal correlations (which are correlations in things which we are concerned with), which would render impossible some transformation on entangled states merely because it might produce an embarrassing result. Either a process is impossible — and in particular not possible on product states — or it is possible, and any embarrassment about the outcome for entangled states is our own, on account of the difficulty in understanding what has happened. What is special about entanglement is the way it challenges our classically-motivated preconceptions, not how entangled states themselves evolve in time.
+",124,,124,,5/17/2018 9:20,5/17/2018 9:20,,,,26,,,,CC BY-SA 4.0 +2065,2,,2060,5/15/2018 15:14,,7,,"You may be interested in the answers to this question. One example of a degenerate code beating the quantum Hamming bound is here. I also have a numerical example of a small violation in my own work, here. In Figure two, you will see a zoomed in section. Essentially, the black line is the quantum Hamming bound (that may not be entirely obvious from what is written!), and the grey line is an approximation of what can be achieved with something related to the Toric code. There will be other examples as well!
+ +There appear to be a number of results about classes of degenerate codes that do not violate the quantum Hamming bound (e.g. here and here). I haven't read them, so don't know how useful they are, but the abstracts suggest that they provide a nice counter-point, conveying the rarity of good degenerate codes.
+",1837,,1837,,5/15/2018 16:30,5/15/2018 16:30,,,,1,,,,CC BY-SA 4.0 +2066,2,,2058,5/15/2018 19:01,,-3,,"No law of physics states that we must be able to evolve a sub-system of the universe on its own.
+ +There would be no way to definitively test such a law.
+ ++ +
The density matrix of the universe must have a trace of 1 and be positive semi-definite, by the mathematical definition of probabilities1. Any change in the universe must1 preserve this, for mathematical reasons and due to definitions. If $\rm{Tr}(\rho_{\rm{universe}})\lt1$, you just haven't included the whole universe in $\rho_{\rm{universe}}$. If it's more than 1, or if $\rho_{\rm{universe}}<0$, what you have is not actually a density matrix, by the definition of probability1.
+ +So the map: $\rho_{\rm{universe}}(0)\rightarrow\rho_{\rm{universe}}(t)$ must1 be positive and trace-preserving.
+ +For convenience, we like to model sub-regions of the universe, and introduce complete positivity for that. But one day an experiment might come along that we find impossible to explain2, perhaps because we have chosen to model the universe in a way that's not compatible with how the universe actually works.
+ +If we assume gravity doesn't exist, and we can magically compute anything we want, we believe that evolving $\rho_{\rm{universe}}$ using the right positive trace-preserving map, then doing a partial trace over all parts of the universe not of concern, will give accurate predictions. +Introducing the notion of modeling only a sub-system of $\rho_{\rm{universe}}$, using a CPT map, is also something we believe will work, but we might bet slightly less on this, because we've added the assumption that sub-systems evolve this way, not just the universe as a whole.
+ ++1: Even this is debatable because the relationship between a wavefunction or density matrix and probabilities comes from a postulate of quantum mechanics called the Born rule, which until fewer than 10 years ago was never tested at all, and still has only been confirmed to be true within an $\epsilon$, and for a particular system: If Born's rule isn't true, Eq. 6 of this would not be zero. To test if Born's rule is true for a particular system (in this case, photons coming from some particular source), you would have to do an infinite number of instances, of all 7 of these experiments, or come up with a different way to test Born's rule (and I don't know of any). In 2009 we published this saying that Born's rule was true (for this system) to within an $\epsilon$ that was smaller than the experimental uncertainty, so we only know Born's rule is true for this system, and to within a precision limited by the experiment. + +
2: This is actually already the case, but let's pretend that gravity does not exist and that quantum mechanics (QED+QFD+QCD) is correct, and we still find it impossible to explain something, despite having (somehow) magical computer power to compute anything we want instantly.
+",2293,,2293,,5/15/2018 23:57,5/15/2018 23:57,,,,6,,,,CC BY-SA 4.0 +2068,1,2069,,5/16/2018 1:45,,8,343,"I am aware that of the difference of Adiabatic Quantum Computing (AQC) and Quantum Annealing (QA) as explained here. However, another term which came up in some papers was Adiabatic Quantum Optimization (AQO). Where does AQO fit in among AQC and QA?
+ +It seems that it is another name for QA and is restricted to solving the Ising model, just like D-Wave's QA? I would think AQO is more general than QA where QA is a form of AQO where its Hamiltonian can be any algebraic function of spin variables without restrictions on the interaction, unlike the Ising model.
+ +Anyone mind clarifying this? Thank you!
+",2398,,26,,12/13/2018 19:50,12/13/2018 19:50,Adiabatic Quantum Computing vs Adiabatic Quantum Optimization vs Quantum Annealing,I'm very happy my answer from 3 years ago to that question is still helping people!
+ +The answer to your new question is found here:
+ +Notice that there is another term here which is ""Quantum Adiabatic Algorithm"" or QAA. In fact those QAA papers from 2000 and 2001 papers call it ""Quantum Adiabatic Evolution Algorithm"" or QAEA, and ""Quantum Computation by Adiabatic Evolution"" or QCAE.
+ ++ +
I think we should agree on just using the terms AQC and Quantum Annealing to describe the two things in my answer to the question you provided the link to.
+",2293,,2293,,5/17/2018 1:03,5/17/2018 1:03,,,,1,,,,CC BY-SA 4.0 +2070,1,,,5/16/2018 17:42,,4,1008,"A lot of the tutorials on BB84 protocol talks about these two measurement bases, 'Rectilinear' or 'Vertical-Horizontal' and 'Diagonal'. I understand that it is possible to create a physical device that would be able to measure a qubit in both vertical and horizontal direction, or in other words, in 'Rectilinear' basis, but what would be the matrix representation of it?
+ +For example, we can use $\lvert 0 \rangle \langle 0 \lvert$ to measure a qubit in the $\lvert 0 \rangle$ basis and $\lvert 1 \rangle \langle 1 \lvert$ to measure in the $\lvert 1 \rangle$ basis. +But what would be the combined measurement basis which we could call 'rectilinear' or 'vertical-horizontal'?
+",2403,,26,,12/23/2018 12:28,12/23/2018 12:28,'Rectilinear' and 'Diagonal' Basis in BB84 Protocol,For the diagonal basis, the measurement operators are the $|0\rangle\langle 0|$ and $|1\rangle\langle 1|$, as stated in the question. For the other basis, any mutually unbiased basis will do, but people usually go for the two operators $(|0\rangle+|1\rangle)(\langle 0|+\langle 1|)/2$ and $(|0\rangle-|1\rangle)(\langle 0|-\langle 1|)/2$.
+ +The labels of which basis you call what are fairly arbitrary, but I think that the rectilinear basis is usually the one that corresponds with horizontal/vertical polarisation and is labelled 0/1. The diagonal basis is then the other one.
+",1837,,1837,,5/16/2018 20:57,5/16/2018 20:57,,,,0,,,,CC BY-SA 4.0 +2072,2,,2070,5/16/2018 21:34,,6,,"Talking about bases such as $\left|0\rangle\langle0\right|$ and $\left|1\rangle\langle1\right|$ (or the equivalent vector notation $\left|0\right>$ and $\left|1\right>$, which I'll use in this answer) at the same time as 'horizontal' and 'vertical' are, to a fair extent (pardon the pun) orthogonal concepts.
+ +On a Bloch sphere, there are 3 different orthonormal bases - we generally consider $\left|0\right\rangle$ and $\left|1\right\rangle$; $\frac{1}{\sqrt 2}\left(\left|0\right\rangle+\left|1\right\rangle\right)$ and $\frac{1}{\sqrt 2}\left(\left|0\right\rangle-\left|1\right\rangle\right)$; $\frac{1}{\sqrt 2}\left(\left|0\right\rangle+i\left|1\right\rangle\right)$ and $\frac{1}{\sqrt 2}\left(\left|0\right\rangle-i\left|1\right\rangle\right)$. I'll refer to these as the 'quantum information bases' as this is the notation generally used in quantum information.
+ +That looks a bit of a mess, so we can also write this as $\left|\uparrow_z\right\rangle$, $\left|\downarrow_z\right\rangle$; $\left|\uparrow_x\right\rangle$, $\left|\downarrow_x\right\rangle$; $\left|\uparrow_y\right\rangle$, $\left|\downarrow_y\right\rangle$, where the different bases are now labelled as $x, y$ and $z$. In terms of spin-half particles, this has a natural definition of up/down spin in each of those directions. However, there is freedom in choosing which direction (in the lab) these axes are in (unless otherwise constrained).
+ +Photons (used in the BB84 protocol) aren't spin-half particles (they have a spin of one), but nevertheless have similarities to this - the 'axes' are the possible directions of the polarisation of a photon, only instead of labelling these as $x, y$ and $z$, they're labelled as horizontal/vertical, diagonal/antidiagonal and left-/right-circular, or in vector notation, this is shortened to $\left|H\right>$, $\left|V\right>$; $\left|D\right>$, $\left|A\right>$; $\left|L\right>$ and $\left|R\right>$. These can then be mapped on to the 'quantum information' bases above, although which basis gets labelled as $\left|0\right>$ and $\left|1\right>$ is somewhat arbitrary.
+ +For the BB84 protocol (and indeed, frequently used in other applications), the rectilinear (vertical/horizontal) basis is the one labelled using $\left|0\right>$ and $\left|1\right>$.
+ +That is: $$\left|H\right>=\left|0\right>$$ +$$\left|V\right>=\left|1\right>$$ +$$\left|D\right>=\frac{1}{\sqrt 2}\left(\left|H\right\rangle+\left|V\right\rangle\right)=\frac{1}{\sqrt 2}\left(\left|0\right\rangle+\left|1\right\rangle\right)$$ +$$\left|A\right>=\frac{1}{\sqrt 2}\left(\left|H\right\rangle-\left|V\right\rangle\right)=\frac{1}{\sqrt 2}\left(\left|0\right\rangle-\left|1\right\rangle\right)$$ +$$\left|R\right>=\frac{1}{\sqrt 2}\left(\left|H\right\rangle+i\left|V\right\rangle\right)=\frac{1}{\sqrt 2}\left(\left|0\right\rangle+i\left|1\right\rangle\right)$$ +$$\left|L\right>=\frac{1}{\sqrt 2}\left(\left|H\right\rangle-i\left|V\right\rangle\right)=\frac{1}{\sqrt 2}\left(\left|0\right\rangle-i\left|1\right\rangle\right)$$
+ +If you want to measure in any of these bases, use the 'projectors' of that basis. That is, if you want to measure in the rectilinear basis, the projectors are $\left|H\rangle\langle H\right|$ and $\left|V\rangle\langle V\right|$. Similarly, in the diagonal basis, $\left|D\rangle\langle D\right|$ and $\left|A\rangle\langle A\right|$; and in the circularly polarised basis, $\left|L\rangle\langle L\right|$ and $\left|R\rangle\langle R\right|$
+",23,,,,,5/16/2018 21:34,,,,1,,,,CC BY-SA 4.0 +2073,1,,,5/17/2018 0:23,,5,303,"If we only assume that the wavefunction of the universe evolves according to $e^{-iHt}$, is there any proof that all subsystems of the universe (partial traces over parts of the universe) must evolve according to a completely positive, trace-preserving (CPTP) map?
+ +An example of a perfectly valid quantum map that is not completely positive is given in the paragraph containing Eq. 6 of the paper: Who's afraid of not completely positive maps?. This was possible because they made the system and its environment entangled at the time $t=0$. So my question is whether such a proof exists for the case where there is no initial entanglement.
+",2293,,26,,12/31/2018 23:33,12/31/2018 23:33,"Only assuming the universe evolves according to a positive trace-preserving map, is there a proof that all subsystem evolution must be CPTP?",Many papers assert that Hamiltonian simulation is BQP-complete +(e.g., +Hamiltonian simulation with nearly optimal dependence on all parameters and Hamiltonian Simulation by Qubitization).
+ +It is easy to see that Hamiltonian simulation is BQP-hard because any quantum algorithm can be reduced to Hamiltonian simulation, but how is Hamiltonian simulation in BQP?
+ +i.e., what precisely is the Hamiltonian simulation decision problem in BQP and under what conditions on the Hamiltonian?
+",1885,,55,,09-04-2020 11:48,1/22/2023 15:55,What are examples of Hamiltonian simulation problems that are BQP-complete?,There are plenty of different variants, particularly with regards to the conditions on the Hamiltonian. It's a bit of a game, for example, to try and find the simplest possible class of Hamiltonians for which simulation is still BQP-complete.
+The statement will roughly be along the lines of: let $|\psi\rangle$ be a (normalised) product state, $H$ be a Hamiltonian from some particular class (e.g. consisting only of nearest-neighbour couplings on a one-dimensional lattice), $\hat O$ an observable comprising a tensor product of one-body operators such that $\|\hat O\|\leq 1$, and $t$ be a time. Given the promise that $\langle\psi|e^{iHt}\hat O e^{-iHt}|\psi\rangle$ is either greater than $\frac12+a$ or less than $\frac12-a$ for some $a$ (e.g. $a=\frac16$), decide which is the case.
++
Further Details
+Hamiltonian Simulation is BQP-hard
+The basic construction (originally due to Feynman, here tweaked a bit) basically shows how you can design a Hamiltonian that implements any quantum computation, including any BQP-complete computation. The observable you would measure is just $Z$ on a particular output qubit, the two measurement outcomes corresponding to 'yes' and 'no'.
+The simplest sort of Hamiltonian you might think of is to consider a computation of $N-1$ sequential unitaries $U_n$ acting on $M$ qubits, starting from a state $|0\rangle^{\otimes M}$. Then you can introduce an extra $N$ qubits, and specify the Hamiltonian +$$ +H=\frac{2}{N}\sum_{n=1}^{N-1}\sqrt{n(N-n)}\left(|10\rangle\langle 01|_{n,n+1}\otimes U+|01\rangle\langle 10|_{n,n+1}\otimes U^\dagger\right). +$$ +If you prepare your initial state as $|1\rangle|0\rangle^{\otimes(N-1)}|0\rangle^{\otimes M}$ then after a time $N\pi/4$, it will be in a state $|0\rangle^{\otimes (N-1)}|1\rangle|\Phi\rangle$ where $|\Phi\rangle$ is the output of the desired computation. The funny coupling strengths that I've used here, the $\sqrt{n(N-n)}$ are chosen specifically to give deterministic evolution, and are related to the concept of perfect state transfer. Usually you'll see results stated with equal couplings, but probabilistic evolution.
+To see how this works, you define a set of states +$$ +|\psi_n\rangle=|0\rangle^{\otimes(n-1)}|1\rangle|0\rangle^{\otimes{N-n}}\otimes\left(U_{n-1}U_{n-2}\ldots U_1|0\rangle^{\otimes M}\right). +$$ +The action of the Hamiltonian is then +$$ +H|\psi_n\rangle=\frac2N\sqrt{(n-1)(N+1-n)}|\psi_{n-1}\rangle+\frac2N\sqrt{n(N-n)}|\psi_{n+1}\rangle, +$$ +which proves that the evolution is restricted to an $N\times N$ subspace which is represented by a tridiagonal matrix (which is the specific thing studied in perfect state transfer).
+Of course, this Hamiltonian doesn't have any particularly nice properties - it is highly non-local, for example. There are many tricks that can be played to simplify the Hamiltonian to being, for example, one-dimensional. It can even be translationally invariant if you want, at the cost of having to prepare a more complex initial product state (at that point, the computation is no longer encoded in the Hamiltonian, which is universal, but is encoded in the input state). See here, for example.
+(Local) Hamiltonian simulation is in BQP
+The evolution of any Hamiltonian which is local on some lattice, acting on an initial product state, for a time that is no more than polynomial in the system size, can be simulated by a quantum computer, and any efficiently implementable measurement can be applied to estimate an observable. In this sense, you can see that Hamiltonian simulation is no harder than a quantum computation, the counter-point to the previous statement that quantum computation is no harder than Hamiltonian simulation.
+There are many ways to do this (and there have been some recent papers that show significant improvements in error scaling for certain classes of Hamiltonian). Hre's quite a simple one. Take the Hamiltonian $H$ that you want to simulate. Split it up into different parts, $H_i$, each of which commutes. For example, on a nearest-neighbour Hamiltonian on some graph, you don't need more pieces than the maximum degree of the graph. You then Trotterize the evolution, writing the approximation +$$ +e^{iHt}\approx \left(e^{-iH_1\delta t}e^{-iH_2\delta t}\ldots e^{-iH_n\delta t}\right)^{t/\delta t} +$$ +So, you just have to construct a circuit that implements terms like $e^{-iH_1\delta t}$, which is composed of commuting terms $H_1=\sum_nh_n$, each of which acts only on a small number of qubits. +$$ +e^{-iH_1\delta t}=\prod_{n}e^{-ih_n\delta t} +$$ +Since this is just a unitary on a small number of terms, a universal quantum computer can implement it.
+",1837,,2927,,1/22/2023 15:55,1/22/2023 15:55,,,,0,,,,CC BY-SA 4.0 +2082,1,2084,,5/17/2018 11:22,,30,3203,"I am a computer science student and am currently searching for resources from where I can learn about quantum computers, quantum computing models, their working principles, their gates and some simple quantum algorithms.
+",2405,,26,,12/13/2018 19:50,1/30/2022 17:43,Are there any organised resources available from where I can begin my quantum computing studies?,The book Quantum computation and quantum information by Nielsen and Chuang is a good read in order to introduce yourself to the world of quantum computation. The book assumes minimal prior experience with quantum mechanics and with computer science, aiming instead to be a self-contained introduction to the relevant features of both, so it is really a nice starting point for anyone who wishes to introduce himself to world of quantum information science.
+",2371,,15,,5/17/2018 21:00,5/17/2018 21:00,,,,0,,,,CC BY-SA 4.0 +2084,2,,2082,5/17/2018 12:37,,14,,"A curated list of resources can be found here.
+ +In case of the link above one day going dead, I should pick out some highlights. Though this will be entirely subjective
+ +-
+
- IBM Q Experience user guide +
- Tutorial for QISKit SDK +
- Preskill's lecture notes +
- Open course by MIT +
- Open course by Keio University +
It really depends on where your brain is at. In particular, how much mathematics you have under your belt. Much of what you will need to understand is contained within linear algebra (over the complex numbers.) Zooming in more: it's all in the tensor product. Most explanations I see of how tensoring works are brutally difficult to understand as a novice. In fact, the case can be made that the whole field of quantum computing has been held back by our understanding of tensor products and ability to work with them (calculate.) In this vein, I would highly recommend the recent book by Coecke and Kissinger ""Picturing Quantum Processes."" Although perhaps you would like to struggle with a more traditional text first, in order to more appreciate the diagrammatic approach.
+",263,,,,,5/17/2018 14:36,,,,0,,,,CC BY-SA 4.0 +2093,2,,1679,5/17/2018 19:10,,2,,"That Wikipedia article you mention says ""Blockchain security methods include the use of public-key cryptography."" The most widely used pubic-key cryptography methods are RSA and some elliptic curve methods. Quantum computers are a threat to both RSA and elliptic curve methods because they rely on it being difficult to factor large number or to calculate difficult discrete logarithms, and Peter Shor showed in 1994 that a quantum computer can perform both these tasks with exponentially fewer arithmetic operations than a classical computer.
+ +If it is possible to build a big enough quantum computer, most if not all blockchain implementations will be at threat because of relying on public-key cryptography implementations which are not safe against quantum computing.
+",2293,,,,,5/17/2018 19:10,,,,1,,,,CC BY-SA 4.0 +2094,2,,1679,5/17/2018 20:38,,7,,"++Are the current implementations of blockchain resistant to attacks using quantum computation?
+
Quick answers:
+-
+
Resistant against near-term technology? Sure.
+
+Reliably secure in the long term? Probably not.
+
+Will this pose a major problem? Very likely not.
+
+Is this risk unique to blockchains? Nope.
+
+
Because even if quantum computers would become a major threat to current implementations, the community could just elect to do a hard fork to post-quantum cryptography.
+Not to say that blockchain technology developers and researchers don't need to worry about working on this issue, though I'd imagine that the average user needn't be concerned with this particular threat.
+Also worth noting that other financial institutions, including banks, would be prone to a similar risk in some weird hypothetical world in which people inexplicably elected against upgrading their crypto. For example, hackers could use quantum computers to crack a financial institution's TLS/SSL certificate, allowing them to man-in-the-middle attack (random 2015 paper).
++
Long answer
+Here's a 2017 paper that projects that Bitcoin could potentially become vulnerable by 2027, using generous assumptions:
+++The key cryptographic protocols used to secure the internet and financial transactions of today are all susceptible to attack by the development of a sufficiently large quantum computer. One particular area at risk are cryptocurrencies, a market currently worth over 150 billion USD. We investigate the risk of Bitcoin, and other cryptocurrencies, to attacks by quantum computers. We find that the proof-of-work used by Bitcoin is relatively resistant to substantial speedup by quantum computers in the next 10 years, mainly because specialized ASIC miners are extremely fast compared to the estimated clock speed of near-term quantum computers. On the other hand, the elliptic curve signature scheme used by Bitcoin is much more at risk, and could be completely broken by a quantum computer as early as 2027, by the most optimistic estimates. We analyze an alternative proof-of-work called Momentum, based on finding collisions in a hash function, that is even more resistant to speedup by a quantum computer. We also review the available post-quantum signature schemes to see which one would best meet the security and efficiency requirements of blockchain applications.
+–"Quantum attacks on Bitcoin, and how to protect against them" (2017-10-28)
+
That said, I'm not too sure how relevant a concern this might be in practice as it seems like that the situation'll change before that point. Even if Bitcoin's still around and going strong by the time it could be attacked, various mitigation techniques might go into effect.
+The "Weakness" article on Bitcoin's wiki doesn't even mention quantum stuff, though their article on "Myths" does:
+++Quantum computers would break Bitcoin's security
+
+While ECDSA is indeed not secure under quantum computing, quantum computers don't yet exist and probably won't for a while. The DWAVE system often written about in the press is, even if all their claims are true, not a quantum computer of a kind that could be used for cryptography. Bitcoin's security, when used properly with a new address on each transaction, depends on more than just ECDSA: Cryptographic hashes are much stronger than ECDSA under QC.
+Bitcoin's security was designed to be upgraded in a forward compatible way and could be upgraded if this were considered an imminent threat (cf. Aggarwal et al. 2017, "Quantum attacks on Bitcoin, and how to protect against them").
+See the implications of quantum computers on public key cryptography.
+The risk of quantum computers is also there for financial institutions, like banks, because they heavily rely on cryptography when doing transactions.
+–"Myths", bitcoinwiki
+
Regarding the point about updating mentioned above, it's that while Bitcoin and other blockchains do tend to require standard algorithms that may be foreseeably attacked by quantum computers, before that's an issue, they can basically just do a hard fork, which is basically an update that everyone in the network migrates to, enabling stuff like algorithm changes.
+++What is 'Hard Fork'
+
A hard fork (or sometimes hardfork), as it relates to blockchain technology, is a radical change to the protocol that makes previously invalid blocks/transactions valid (or vice-versa). This requires all nodes or users to upgrade to the latest version of the protocol software. Put differently, a hard fork is a permanent divergence from the previous version of the blockchain, and nodes running previous versions will no longer be accepted by the newest version. This essentially creates a fork in the blockchain: one path follows the new, upgraded blockchain, and the other path continues along the old path. Generally, after a short period of time, those on the old chain will realize that their version of the blockchain is outdated or irrelevant and quickly upgrade to the latest version.–"Hard Fork", Investopedia
+
Of course, pushing a hard fork requires getting much of the community to accept it, though since pretty much all members of a cryptocurrency network wouldn't want to get hacked/scammed/etc., a hard fork pushed to avert a foreseeable risk of attack by quantum computers would almost certainly be uncontroversial.
+",15,,-1,,6/18/2020 8:31,5/17/2018 20:53,,,,10,,,,CC BY-SA 4.0 +2095,1,,,5/18/2018 5:15,,8,172,"In a simple form, Bell's theorem states that:
+ +++ +No physical theory of local hidden variables can ever reproduce all of the predictions of quantum mechanics.
+
Bell developed a series of inequalities to provide specific experimental examples to distinguish between the predictions of any theory relying on local hidden variables and those of quantum mechanics. As such, Bell test inequality experiments are of fundamental interest in quantum mechanics. However, if one wants to do things properly, one realizes that there are a number of loopholes that affects, in different degrees, all experiments trying to perform Bell tests.[1] Experiments trying to close these loopholes tend to be unique rather than routine. One of the results of having general-purpose quantum computers, or networks thereof, would be the ability to routinely perform sophisticated quantum experiments.
+ +Question: What requirements would have to fulfill a general-purpose quantum computer (network) to be able to implement Bell tests that are at least as loophole-free as the best realization that has been done so far?
+ +For clarity: ideally the best answer will take a quantum computing approach and contain close-to-engineering details, or at least close-to-architecture. For example, writing the experiment as a simple quantum circuit, one of the current architectures can be chosen and from that one would make some realistic order-of-magnitude estimates to the required times of the different quantum gates / measurements and of the required physical distance between the different qubits.
+ +[1] As commented by @kludg, it has been argued that ""..no experiment, as ideal as it is, can be said to be totally loophole-free."", see Viewpoint: Closing the Door on Einstein and Bohr’s Quantum Debate
+",1847,,55,,04-10-2021 08:29,04-10-2021 08:29,How would a Quantum Computer (network) perform loophole-free Bell tests?,When people talk about a loophole free Bell test, what they really mean is that the two loopholes that most concern the majority of people are closed simultaneously: the measurement loophole and the locality loophole.
+ +Let us briefly review the protocol:
+ +-
+
A Bell state $(|00\rangle+|11\rangle)/\sqrt{2}$ is produced, and two parties, Alice and Bob, each take one qubit.
+Alice and Bob must be separated by a distance $d$.
+Alice and Bob each pick a random bit value.
+If Alice's random bit value, $x$, is 0, she measures her qubit in the $Z$ basis. If it's 1, she measures in the $X$ basis. Her measurement outcome is a bit, recorded in the variable $A_x$.
+If Bob's random bit value is $y\in\{0,1\}$, he measures in the basis $(Z+(-1)^yX)/\sqrt{2}$. His measurement outcome is a bit, recorded in the variable $B_y$.
+Alice and Bob repeat this many times, and evaluate the expected value of $$S=A_0(B_0+B_1)+A_1(B_0-B_1).$$
+
Closing the locality loophole requires that the two parties that are taking part are separated by a distance $d$ such that the time between Alice's measurement basis being chosen, and Bob's answer being given is less than $d/c$, where $c$ is the speed of light (so that there is no way an adversary choosing Bob's answer can know Alice's measurement basis). It also requires, symmetrically, that Alice's answer is given no later than a time $d/c$ after Bob's measurement choice is made.
+ +Closing the measurement loophole requires the use of detectors that have a sufficiently high accuracy (otherwise, an adversary obeying a Local Hidden Variable model could replace your detectors with better detectors, and use the margin of error to throw away results that would betray the presence of eavesdropping/manipulation). The precise value of this threshold depends on your precise formulation of the Bell test. The commonly quoted value is a detector efficiency of about $83\%$ for the CHSH test.
+ +Recently, there have been experiments that have closed both these loopholes simultaneously. See here, for example. Their results are good enough that they can quantify the likelihood of there being a local hidden variable model that describes their results ($P=0.039$). Ultimately, if you want to do better, you either need devices that perform better than theirs, or to perform more runs of the experiment. That is, perhaps, now the main experimental challenge; to improve the speed of such devices so that it doesn't take 18 days to generate 245 trials! These experiments also claim to remove the freedom of choice loophole, wherein one worries that the random number generators that are used for choosing the measurement bases of Alice and Bob are also governed by the same local hidden variable model, instead of generating perfect randomness that is uncorrelated with the rest of the experiment.
+ +In terms of a quantum computing architecture for implementing this, that is not a particularly natural issue: for a quantum computer, one wants to be able to create as much connection and interaction between the qubits as possible, which is rather the opposite of needing to separate them over great distances. I suppose the sort of context which is starting to generate the right scenario are the designs for scalable ion trap quantum computers, where there are multiple separated traps, each of which only interacts occasionally. If each of these were far enough apart, you could think of a loophole-free Bell test. I believe the measurement efficiencies in these scenarios are high enough. The question then is, how far apart do these different locations have to be to close the locality loop hole? I haven't done any sort of calculation based on real data, but I think the answer is of the order of kilometers, i.e. completely unreasonable for a single computer. For me, those would be separate computers, working very hard to cooperatively compute using the minimum of shared resources (i.e. entanglement).
+",1837,,1837,,5/18/2018 7:30,5/18/2018 7:30,,,,7,,,,CC BY-SA 4.0 +2097,1,2099,,5/18/2018 19:46,,12,780,"Schrödinger wrote a letter to Einstein after the 1935 EPR paper, and in that letter Schrödinger used the German word ""Verschränkung"" which translates into ""entanglement"", but when was the word first used in English?
+ +Schrödinger's 1935 paper written in English, called Discussion of Probability Relations between Separated Systems, says (according to Wikipedia) ""I would not call [entanglement] one but rather the characteristic trait of quantum mechanics, the one that enforces its entire departure from classical lines of thought"" which means the concept was there but it whatever word he used for it was not entanglement (hence the square brackets). Unfortunately I do not have access to the full paper.
+",2293,,2293,,5/18/2018 20:24,1/24/2021 22:58,When was the first use of the word Entanglement?,The Toric code Hamiltonian is:
$\sum_{x,y}\left( \prod_{i\in p(x,y)} Z_{ixy} + \prod_{i\in v(x,y)} X_{ixy} \right),$
+ +where the $v$ and $p$ are defined according to this picture (courtesy of James Wooton's contribution to Wikipedia):
+ +At the moment we have an infinite 2D lattice:
$x\rightarrow \pm \infty$
+$y\rightarrow \pm \infty$.
But if we set periodic boundary conditions such that (and feel free to edit the question if I am incorrect about this):
$p(x+10,y)=p(x,y)$
+$v(x,y+10)=v(x,y)$,
We get the follownig torus (image courtesy of James Wooton's contribution to Wikipedia) :
+ +Now in my periodic boundary conditions, I chose to add $+10$ but could have added some other number instead. How does this ""size of the torus"" affect the function of the toric code?
+",2293,,10480,,02-10-2021 07:07,02-10-2021 21:34,How does the size of a toric code torus affect its ability to protect qubits?,I managed to get access to the paper mentioned in the question. Schrödinger in 1935 (the same year the original EPR paper was published) wrote in English: ""By the interaction the two representatives (or $\psi$-functions) have become entangled."" This was in the abstract.
+ +He also wrote later in the paper: ""What constitutes the entanglement is that $\psi$ is not a product of a function of x and a function of y.""
+ +He also used the term ""disentanglement""
+ +However the use of the term as found by searching: quantum entanglement
+in Google Scholar indicates that the term was merely doubling every 10 years until roughly 1990 when it went up by a factor of 5 in a 10-year period, followed by further factor of 6 in the next 10-year period:
Data was collected just now:
1900-1940: 63 results
+1900-1950: 93 results
+1900-1960: 146 results
+1900-1970: 313 results
+1900-1980: 718 results
+1900-1990: 1700 results
+1900-2000: 9380 results
+1900-2010: 61700 results
+1900-2020: 151000 results
For example, has anyone seen something like:
+""quqrit"" for a 4-level system[1], or
+""qupit"" for a 5-level system[2] ?
1 From ""quad"" or ""quart"" since ""tetra"" would be qutrit, which is already a 3-level system.
+2 From ""penta"" since ""quint"" would interfere with quqrit for 4-level system.
I understand that we could call a quqrit a ""spin-3/2 particle"" which would be overloading the meaning of spin, but I wonder if these terms have ever been used. I have searched ""quqrit"" and ""qupit"" on Google but what if it's not called ""quqrit"" but something else? Also, perhaps no one had the bravery to publish something with these words written down but have been used orally at conferences. Surprisingly, after asking this question I found one paper using the term ""qupit"" but the word only appears in the title and nowhere else, so it's not clear what their definition of qupit is!
+",2293,,2293,,5/19/2018 2:08,06-07-2018 07:32,Do any specific types of qudits other than qubits and qutrits have a name?,After a lot of searching, it appears that the word ""quqrit"" has indeed been used in one (but I found only one!) paper from 2011, and indeed it was used to describe a 4-level system. But the word ""quqit"" is used to describe 4-level systems in two papers [1][2] dating back to 2004. This time there's four different authors in total, but two of them are on both papers so no independent groups using this term (as far as I have found).
+ +As for higher-order qudits beyond $d=5$, it appears to be an open question.
+",2293,,2293,,5/19/2018 4:47,5/19/2018 4:47,,,,0,,,,CC BY-SA 4.0 +2102,2,,2100,5/19/2018 5:46,,8,,"There is no standard name for a qudit for $d>3$. The community has mostly settled on the term qudit (but you will still find qunit or quNit, for example, using $n$ or $N$ instead of $d$ in some older papers).
+ +You will find the odd paper where an individual author will pick a name for the $d=4$ case. I’ve certainly seen ququad and ququart. But I think mostly people just use qudit, and specify $d$.
+ +The other term that you'll see (thanks to Niel de Beaudrap for pointing it out) is qupit, a quantum system where the Hilbert space dimension is an odd prime, $p$.
+",1837,,23,,06-07-2018 07:32,06-07-2018 07:32,,,,2,,,,CC BY-SA 4.0 +2103,2,,2098,5/19/2018 6:23,,6,,"The Toric code is an error correcting code. The distance of the code (I.e. the number of local operations required to convert one logical state into an orthogonal one) is equal to $N$, where the Toric code is defined on an $N\times N$ grid.
+ +One of the places that the performance of the Toric code really wins out is that although it is only distance $N$, the vast majority of sets of $N$ single qubit errors can be corrected, and it is only once you get $O(N^2)$ errors that you get killed. That means that as $N\rightarrow\infty$, those $O(N)$ terms vanish, and you get a finite per-qubit error rate as a threshold for error correction. For finite $N$, the error correcting threshold will be lower.
+",1837,,,,,5/19/2018 6:23,,,,0,,,,CC BY-SA 4.0 +2104,2,,2012,5/19/2018 7:49,,2,,"I don't know the translation into physics, but the circuit you want for the most basic demonstration is the following:
+
+Here, $|+\rangle=(|0\rangle+|1\rangle)/\sqrt{2}$, and the gates are controlled-not gates and controlled-phase gates. The state $|\psi\rangle$ can be any input state initially. The first time the circuit is run prepares the $|\psi\rangle$ qubits in a 4-qubit Toric code (up to some corrections depending on what measurement results you got). Repeat the measurements again, and you get a round of error correction. In effect, what the first qubit is doing is measuring the expectation value of the observable $XXXX$ on the Toric code qubits, while the second qubit measures the $ZZZZ$ observable.
I seem to remember that Jiannis Pachos (and coauthors) explicitly described the smallest Toric code implementation possible (which I guess was this version), but I can't seem to find the paper. I had assumed that JamesWooton would have jumped in by now to tell you where that paper is. It must be commented, however, that such a small size of Toric Code is completely hopeless for error correcting properties; you cannot even correct for single-qubit errors!
+",1837,,1837,,5/19/2018 9:12,5/19/2018 9:12,,,,2,,,,CC BY-SA 4.0 +2105,1,2124,,5/19/2018 10:26,,7,75,"When applying each of the six degree of freedom rotations (or certain combinations of them) in an SO(4) using quantum gates, the results I expected are produced. For example, the following circuit in Craig Gidney's Quirk tool demonstrates rotations in three degrees of freedom, along with some displays of the resulting matrices expressed as percentages:
+ +
However, when applying some combinations of rotations, such as the following, results I didn't expect are produced in the final matrix:
+ +In contrast, the results I am expecting are the following: +$$ +\begin{bmatrix} + .73 & .07 & .13 & .07 \\ + .00 & .73 & .15 & .13 \\ + .13 & .07 & .73 & .07 \\ + .15 & .13 & .00 & .73 +\end{bmatrix} +$$
+ +For convenience, here is a link to the Quirk circuit with all six degree of freedom rotations, albeit with an unexpected final result. The results I expect are the following:
+ +$$ +\begin{bmatrix} + .62 & .01 & .08 & .29 \\ + .11 & .80 & .01 & .08 \\ + .13 & .07 & .80 & .01 \\ + .15 & .13 & .11 & .62 +\end{bmatrix} +$$
+ +I don't know enough about using ancilla bits and uncomputation techniques to apply them to this, but I suspect that it might explain part of the unexpected results. Any advice would be greatly appreciated.
+",2421,,26,,12/23/2018 13:52,12/23/2018 13:52,How to avoid error when applying certain combinations of degree of freedom rotations using a quantum circuit?,I am studying Quantum Computing and Information, and have come across the term "surface code", but I can't find a brief explanation of what it is and how it works. Hopefully you guys can help me with this.
+",2422,,55,,6/13/2022 23:18,6/13/2022 23:18,"What is the ""surface code"" in the context of quantum error correction?",The surface codes are a family of quantum error correcting codes defined on a 2D lattice of qubits. Each code within this family has stabilizers that are defined equivalently in the bulk, but differ from one another in their boundary conditions.
+ +The members of the surface code family are sometimes also described by more specific names: The toric code is a surface code with periodic boundary conditions, the planar code is one defined on a plane, etc. The term ‘surface code’ is sometimes also used interchangeably with ‘planar code’, since this is the most realistic example of the surface code family.
+ +The surface codes are currently a large research area, so I’ll just point you towards some good entry points (in addition to the Wikipedia article linked to above).
+ + + +The surface codes can also be generalized to qudits. For more on that, see here.
+",409,,-1,,8/28/2019 8:59,8/28/2019 8:59,,,,2,,,,CC BY-SA 4.0 +2108,1,2122,,5/19/2018 18:56,,8,997,"I am trying to run some code using qiskit, but I get the error message, that I have run out of necessary Experiment Units. I tried to remove pending jobs using the API with the following code
for job in api.get_jobs():
+ if job[""status""] == ""RUNNING"":
+ api.cancel_job(id_job=job[""id""], hub=None, group=None, project=None,
+ access_token=None, user_id=None)
+but it didn't work.
+ +Am I even going in the right direction or is there some other way to retrieve these used Experiment Units? I have read, that they normally are given back just after the execution of program is finished or after 24 hours (depending on which one ends earlier), but I am waiting now for over than two days and nothing happens.
I have some practical difficulties with projective measurements, so I'd welcome inspiration from others. This is beyond the question ""Are true Projective Measurements possible experimentally?"" in that I'm not aiming for perfection but for something practical. In particular, I care about the case where we want to keep computing after a measurement.
+ +Let us say we try to effect an upwards transition between two energy levels, by illuminating the sample with the appropriate wavelength. The transition is only possible if the initial state is occupied, since the final state is outside of out computational basis. For this to be a projective measurement rather than an unitary operation in a larger basis, we need to irreversibly detect this, say by a radiative spontaneous relaxation of this ""final"" state of the transition to a third energy level. If we were subsequently able to go back to the original level (coherently and rapidly), then I assume we'd have a messy work-around for an ideal projective measurement.
+ +The question is: can this be done, or is this scheme fundamentally flawed? If it can be done, please illustrate with examples where this works.
+",1847,,1837,,9/21/2018 7:42,9/21/2018 7:42,Projective measurements: aftermath and restoration,Grover's algorithm is used, among other things, to search an item $\mathbf{y}$ in an unordered list of items $[\mathbf{x}_0, \mathbf{x}_1, ..., \mathbf{x}_{n-1}]$ of length $n$. Even though there are plenty of questions here regarding this topic, I still miss the point.
+ +Searching in a list, the classical way
+ +Normally, I would design a search function this way +$$ \mathrm{search}([\mathbf{x}_0, \mathbf{x}_1, ..., \mathbf{x}_{n-1}], \mathbf{y}) = i \in \mathbb{N} \quad \text{such that } \mathbf{x}_i = \mathbf{y} $$ +So I give the list and the wanted item as inputs, and I receive the position of the item in the list as output. I think I have understood that the information about $\mathbf{y}$ is embedded in the algorithm through the oracle gate $O$, so our function becomes +$$ \mathrm{search}_\mathbf{y}([\mathbf{x}_1, \mathbf{x}_2, ..., \mathbf{x}_n] ) = i \in \mathbb{N} \quad \text{such that } \mathbf{x}_i = \mathbf{y} $$ +Let's make a practical example. Consider searching the ace of spades $1\spadesuit$ in a sequence of 8 cards from a standard 52-card deck:
+ +The list of length $8$ is $[ + \mathbf{x}_0 = J\clubsuit,$ $ + \mathbf{x}_1 = 10\diamondsuit,$ $ + \mathbf{x}_2 = 4\heartsuit,$ $ + \mathbf{x}_3 = Q\clubsuit,$ $ + \mathbf{x}_4 = 3\spadesuit,$ $ + \mathbf{x}_5 = 1\spadesuit,$ $ + \mathbf{x}_6 = 6\spadesuit, $ $ + \mathbf{x}_7 = 6\clubsuit]$.
+ +The wanted element is $\mathbf{x}_5$. I should obtain $\mathrm{search}_{\spadesuit}(cards) = 5$. Each card can be encoded with $\lceil{\log_2 52}\rceil = 6$bits, the list has $8$ elements so we need $6\times 8 = 48$ bits to encode the list. In this case, the oracle $O$ will implement the function: +$$f(\mathbf{x}) = \begin{cases} 1, & \mathbf{x} = 1\spadesuit \\ 0, & \text{otherwise} \end{cases}$$
+ +However, the input of Grover's algorithm is not a state of $48$qubits.
+ +(NB: Image of shuffled deck is taken from here)
+ +Grover and its oracle
+ +Several sources (eg. here - graphically explained) say that the input of the algorithm is different: the input is a state taken from the search space $S = \{ 0, 1, 2, ..., N \} = \{0, 1, 2, ..., 7 \} $ where $N$ is the number of elements of the list. Each number corresponds to the position of an element in the list.
+ +The input of $\mathrm{search}_{\spadesuit}(\cdot)$ is now a $\lceil \log_2 8 \rceil = 3$qubit vector $|\psi\rangle$, which must be a superposition of all the items in the search space $S$.
+ +We know
+ +-
+
- $|0_{3\text{qubits}}\rangle = |000\rangle$ corresponds to $J\clubsuit$; +
- $|1_{3\text{qubits}}\rangle = |001\rangle$ corresponds to $10\diamondsuit$; +
- $|2_{3\text{qubits}}\rangle = |010\rangle$ corresponds to $4\heartsuit$; +
- $|5_{3\text{qubits}}\rangle = |101\rangle$ corresponds to $1\spadesuit$ which is the wanted element; +
- and so on... +
In this case we have +$$\mathrm{search}_{\spadesuit}(|\psi\rangle) = |5_{3\text{qubits}}\rangle$$ +But in this case, our oracle would have to implement the function +$$f(|\psi\rangle) = \begin{cases} 1, & |\psi\rangle = |5_{3\text{qubits}}\rangle \\ 0, & \text{otherwise} \end{cases}$$
+ +Building the oracle requires us to know that $\spadesuit$ is at position 5. What's the point to execute the algorithm if we have already searched for the element in order to build the oracle?
+",1874,,55,,05-03-2021 11:28,05-03-2021 11:57,What's the point of Grover's algorithm if we have to search the list of elements to build the oracle?,Shor's algorithm is expected to enable us to factor integers far larger than could be feasibly done on modern classical computers.
+ +At current, only smaller integers have been factored. For example, this paper discusses factorizing $15=5{\times}3$.
+ +What is in this sense the state-of-art in research? Is there any recent paper in which it says some bigger numbers have been factorized?
+",2426,,26,,12/13/2018 19:51,12/17/2018 10:23,What integers have been factored with Shor's algorithm?,The prime factorization of 21 (7x3) seems to be the largest done to date with Shor's algorithm; it was done in 2012 as detailed in this paper. It should be noted, however, that much larger numbers, such as 56,153 in 2014, have been factored using a minimization algorithm, as detailed here. For a convenient reference, see Table 5 of this paper:
+ + + +$$ +\begin{array}{c} + \textbf{Table 5:}~\text{Quantum factorization records} \\ \hline + \small{ + \begin{array}{cccccc} + \text{Number} & \text{# of factors} & \begin{array}{c}\text{# of qubits} \\ \text{needed} \end{array} & \text{Algorithm} & \begin{array}{c}\text{Year} \\ \text{implemented} \end{array} & \begin{array}{c}\text{Implemented} \\ \text{without prior} \\ \text{knowledge of} \\ \text{solution} \end{array} \\ \hline + 15 & 2 & 8 & \text{Shor} & 2001~\left[2\right] & \chi \\ + & 2 & 8 & \text{Shor} & 2007~\left[3\right] & \chi \\ + & 2 & 8 & \text{Shor} & 2007~\left[3\right] & \chi \\ + & 2 & 8 & \text{Shor} & 2009~\left[5\right] & \chi \\ + & 2 & 8 & \text{Shor} & 2012~\left[6\right] & \chi \\ + 21 & 2 & 10 & \text{Shor} & 2012~\left[7\right] & \chi \\ + 143 & 2 & 4 & \text{minimization} & 2012~\left[1\right] & \checkmark \\ + 56153 & 2 & 4 & \text{minimization} & 2012~\left[1\right] & \checkmark \\ \hline + 291311 & 2 & 6 & \text{minimization} & \text{not yet} & \checkmark \\ + 175 & 3 & 3 & \text{minimization} & \text{not yet} & \checkmark + \end{array}} +\end{array}_{\Large{.}} +$$
+",91,,2293,,5/20/2018 22:07,5/20/2018 22:07,,,,7,,,,CC BY-SA 4.0 +2113,2,,2110,5/20/2018 15:35,,15,,"If you have 8 items in the list (like in your card's example), then the input of the oracle is 3 (qu)bits. Number of cards in the deck (52) is irrelevant, you need 3 bits only to encode 8 cards.
+ +You can think that 3 bits encode the position in the list of the card you are searching; then you don't know the position, but the oracle knows. So if you are searching the ace of spades, then the oracle knows that the ace of spades is the 6th card (or 5th counting from zero) and implements the function +$$ +f(\mathbf{x}) = \begin{cases} 1, & \text{if x = 5, or binary '101'} \\ 0, & \text{otherwise} \end{cases}$$
+ +PS: It is better to think about the Grover's algorithm differently: you have an oracle implementing a boolean function which outputs $1$ for a single combination of input bits, otherwise outputs zero, and your task is to find the combination. The problem has the same complexity as searching in an unsorted list or database, that is why the Grover's algorithm is usually described as searching in an unsorted database. But applying the algorithm to a real-world database search indeed raises questions that are beyond the algorithm itself. Grover's algorithm is just searching for what the oracle knows.
+",2105,,2105,,5/20/2018 16:34,5/20/2018 16:34,,,,4,,,,CC BY-SA 4.0 +2114,1,2116,,5/20/2018 17:02,,8,432,"$\newcommand{\Ket}[1]{\left|#1\right>}$
+ +I understand that in general quantum black box algorithms (such as the ones which play a part in Simon's & Deutsch's algorithm) implement a quantum circuit to compute some function $f\left(x\right)$ in such a way that the input is fed with trailing zero qubits, and the result is the input followed by the output, e.g:
+ +$$\Ket{x}\Ket{0} \rightarrow \Ket{x}\Ket{f(x)}\,.$$
+ +My question is, since basically one can write the above more explicitly as:$$ +\Ket{x}\otimes\Ket{0} \rightarrow \Ket{x}\otimes\Ket{f(x)} +\,,$$whether it is possible, in case $\Ket{x}$ is not a pure state but a superposition, to get an output which ""mixes"" inputs with the wrong outputs.
+ +To clarify what I mean I'll give an example: +Suppose our input is the one qubit superposition:
+ +$$\Ket{x} = \frac{\Ket{0}+\Ket{1}}{\sqrt{2}}$$
+ +Will the result of the black-box circuit be the following tensor product:
+ +$$ +\left\lbrack\frac{\Ket{0}+\Ket{1}}{\sqrt{2}}\right\rbrack +\otimes +\left\lbrack\frac{\Ket{f(0)}+\Ket{f(1)}}{\sqrt{2}}\right\rbrack +$$
+ +(Which I find confusing and unlikely) +Or, the other option which seems to be more natural:
+ +$$\frac{\Ket{0}\Ket{f(0)}+\Ket{1}\Ket{f(1)}}{\sqrt{2}}$$
+ +(Or perhaps both are wrong? :))
+",2428,,15,,5/20/2018 20:17,5/20/2018 20:17,"Clarification needed regarding quantum ""black-box"" circuits",Nice question. +Your second example is correct. I will show this by using Equation 2 from here:
+ +$(A + B)\otimes C = A\otimes C + B\otimes C$.
+ +For your example:
+ +$\left(\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right)\otimes|f(x)\rangle = \frac{|0\rangle\otimes|f(x)\rangle}{\sqrt{2}}+\frac{|1\rangle\otimes|f(x)\rangle}{\sqrt{2}} = \frac{|0\rangle\otimes|f(0)\rangle}{\sqrt{2}}+\frac{|1\rangle\otimes|f(1)\rangle}{\sqrt{2}}$
+ +You can see this being done, for example, in the first line of Page 6 in these lecture notes of Prof. John Watrous.
+",2293,,2293,,5/20/2018 17:58,5/20/2018 17:58,,,,0,,,,CC BY-SA 4.0 +2116,2,,2114,5/20/2018 18:30,,4,,"It is always good to start from considering an example. Suppose you have CNOT gate; then +\begin{align} +\Ket{0}\Ket{0} \rightarrow \Ket{0}\Ket{0}\\ +\Ket{1}\Ket{0} \rightarrow \Ket{1}\Ket{1} +\end{align} +By linearity +\begin{align} +\frac{1}{\sqrt{2}}(\Ket{0}\Ket{0} + \Ket{1}\Ket{0}) \rightarrow \frac{1}{\sqrt{2}}(\Ket{0}\Ket{0}+ \Ket{1}\Ket{1}) +\end{align} +or +\begin{align} +\frac{1}{\sqrt{2}}(\Ket{0} + \Ket{1})\Ket{0} \rightarrow \frac{1}{\sqrt{2}}(\Ket{0}\Ket{0}+ \Ket{1}\Ket{1}) +\end{align} +So your first guess is wrong, but the second guess seems to be true, and it is not hard to convince yourself that it is indeed true.
+",2105,,,,,5/20/2018 18:30,,,,1,,,,CC BY-SA 4.0 +2118,2,,1796,5/20/2018 20:23,,1,,"For Shor's algorthm: +Every experiment has been designed for the specific number being factored. The largest number factored without cheating was 15 which is the smallest non-trivial semi-prime on which to apply Shor's algorithm. Major changes would be needed in the experiment (including in the number of qubits) in order to factor 21, for example. IBM's 50-qubit machine can implement Shor's algorithm on larger numbers, but the noise is so bad that you will only get the correct factors if you're very lucky, and that's why it hasn't been done yet.
+ +For the annealing algorithm: 376289 has been factored with D-Wave's 2048-qubit annealer, and this is not a specific experiment but a general algorithm on an easily programmable machine, but we do not know how this will scale. A very crude upper limit to the number of qubits needed to factor RSA-230 is 5.5 billion qubits (but this can be brought down significantly by better compilers), while Shor's algorithm can do it with 381 qubits.
+",2293,,,,,5/20/2018 20:23,,,,0,,,,CC BY-SA 4.0 +2119,2,,2111,5/20/2018 21:43,,6,,"For Shor's algorthm: +State of the art is still 15. In order to ""factor"" 21 in the paper Heather mentions, they had to use the fact that $21=7\times 3$ to choose their base $a$. This was explained in 2013 in the paper Pretending to factor numbers on a quantum computer, later published by Nature with a slightly friendlier title. The quantum computer did not factor 21, but it verified that the factors 7 and 3 are indeed correct.
+ +For the annealing algorithm: State of the art is 376289. But we do not know how this will scale. A very crude upper limit to the number of qubits needed to factor RSA-230 is 5.5 billion qubits (but this can be brought down significantly by better compilers), while Shor's algorithm can do it with 381 qubits.
+",2293,,,,,5/20/2018 21:43,,,,1,,,,CC BY-SA 4.0 +2120,2,,2111,5/20/2018 23:59,,5,,"The size of the number factored is not a good measure for the complexity of the factorization problem, and correspondingly the power of a quantum algorithm. The relevant measure should rather be the periodicity of the resulting function which appears in the algorithm.
+ +This is discussed in J. Smolin, G. Smith, A. Vargo: Pretending to factor large numbers on a quantum computer, Nature 499, 163-165 (2013). In particular, the authors also give an example of a number with 20000 binary digits which can be factored with a two-qubit quantum computer, with exactly the same implementation that had been used previously to factor other numbers.
+ +It should be noted that the ""manual simplifications"" which the authors perform to arrive at this quantum algorithm is something which has also been done e.g. for the original experiment factoring 15.
+",491,,,,,5/20/2018 23:59,,,,0,,,,CC BY-SA 4.0 +2121,2,,2110,5/21/2018 7:09,,7,,"While it is perhaps easiest for us to think about the function of the oracle as already having computed all these values, that's not what it's doing. In the case you described, the oracle has 8 possible inputs (i.e. encoded in 3 (qu)bits), and the oracle does all the computation that you need on the fly. So, the moment you try to evaluate the oracle for some value $x$, the oracle looks up (in this instance) the card that the value of $x$ corresponds to, and then checks if that card is the marked card. The idea being that each time you call the oracle, it goes through that process once. Overall, you evaluate the function a number of times that's equal to the number of times you call the oracle. The aim of any search algorithm is to call that oracle as few times as possible.
+ +In case this sounds a little circular (given an input $x$, find which card that corresponds to), remember that your look-up table for what $x$ corresponds to what card can be ordered which is a different, simpler, much faster search question.
+ +The key differences in your example compared to a more realistic usage scenario are:
+ +-
+
The search space is usually massive. There's no realistic prospect of precomputing all values. Indeed, that is exactly what we're trying to avoid.
+Usually, we don't actually say 'find the ace of spades'. Instead, there's an $f(x)$ that is non-trivial to evaluate to test if $x$ is the 'marked' item or not. The fact that the oracle can take quite a long time to evaluate, even for a single entry, is what makes the oracle the costly part to implement (and all other gates are given for free) and why you need to minimise the number of calls.
+
So, really, the way a classical search would work on your problem is: pick an $x$ at random. Evaluate $y=f(x)$. If $y=1$, return $x$, otherwise repeat. While the net effect of $f(x)$ is 'is the input $x_0$, the marked entry?', that is not the actual calculation that it does.
+",1837,,,,,5/21/2018 7:09,,,,0,,,,CC BY-SA 4.0 +2122,2,,2108,5/21/2018 7:25,,6,,"Cancel Job is only available for the IBM Q Network, not for IBM Q Experience: https://github.com/QISKit/qiskit-api-py/blob/master/IBMQuantumExperience/IBMQuantumExperience.py#L795
+ +In the next weeks, we hope that it is available for IBM Q Experience too.
+ +Regarding to the credits... we are analyzing the problem. We have refilled your credits.
+ +If you have any other issue, please post in qiskit (https://qiskit.org/) slack public channel :).
+",2436,,2436,,5/21/2018 7:34,5/21/2018 7:34,,,,0,,,,CC BY-SA 4.0 +2123,2,,2106,5/21/2018 8:26,,27,,"The terminology of 'surface code' is a little bit variable. It might refer to a whole class of things, variants of the Toric code on different lattices, or it might refer to the Planar code, the specific variant on a square lattice with open boundary conditions.
+The Toric Code
+I'll summarise some of the basic properties of the Toric code. Imagine a square lattice with periodic boundary conditions, i.e. the top edge is joined to the bottom edge, and the left edge is joined to the right edge. If you try this with a sheet of paper, you'll find you get a doughnut shape, or torus. On this lattice, we place a qubit on each edge of a square.
+Stabilizers
+Next, we define a whole bunch of operators. For every square on the lattice (comprising 4 qubits in the middle of each edge), we write +$$ +B_p=XXXX, +$$ +acting a Pauli-$X$ rotation on each of the 4 qubits. The label $p$ refers to 'plaquette', and is just an index so we can later count over the whole set of plaquettes. On every vertex of the lattice (surrounded by 4 qubits), we define +$$ +A_s=ZZZZ. +$$ +$s$ refers to the star shape and again, will let us sum over all such terms.
+We observe that all of these terms mutually commute. It's trivial for $[A_s,A_{s'}]=[B_p,B_{p'}]=0$ because Pauli operators commute with themselves and $\mathbb{I}$. More care is required with $[A_s,B_p]=0$, bot note that these two terms either have 0 or 2 sites in common, and pairs of different Pauli operators commute, $[XX,ZZ]=0$.
+Codespace
+Since all these operators commute, we can define a simultaneous eigenstate of them all, a state $|\psi\rangle$ such that +$$ +\forall s:A_s|\psi\rangle=|\psi\rangle\qquad\forall p:B_p|\psi\rangle=|\psi\rangle. +$$ +This defines the codespace of the code. We should determine how large it is.
+For an $N\times N$ lattice, there are $N^2$ qubits, so the Hilbert space dimension is $2^{N^2}$. There are $N^2$ terms $A_s$ or $B_p$, which we collectively refer to as stabilizers. Each has eigenvalues $\pm 1$ (to see, just note that $A_s^2=B_p^2=\mathbb{I}$) in equal number, and when we combine them, each halves the dimension of the Hilbert space, i.e. we would think that this uniquely defines a state.
+Now, however, observe that $\prod_sA_s=\prod_pB_p=\mathbb{I}$: each qubit is included in two stars and two plaquettes. This means that one of the $A_s$ and one of the $B_p$ is linearly dependent on all the others, and does not further reduce the size of the Hilbert space. In other words, the stabilizer relations define a Hilbert space of dimension 4; the code can encode two qubits.
+Logical Operators
+How do we encode a quantum state in the Toric code? We need to know the logical operators: $X_{1,L}$, $Z_{1,L}$, $X_{2,L}$ and $Z_{2,L}$. All four must commute with all the stabilizers, and be linearly independent from them, and must generate the algebra of two qubits. Commutation of operators on the two different logical qubits: +$$ +[X_{1,L},X_{2,L}]=0\quad [X_{1,L},Z_{2,L}]=0 \quad [Z_{1,L},Z_{2,L}]=0\quad [Z_{1,L},X_{2,L}]=0 +$$ +and anti-commutation of the two on each qubit: +$$ +\{X_{1,L},Z_{1,L}\}=0\qquad\{X_{2,L},Z_{2,L}\}=0 +$$
+There's a couple of different conventions for how to label the different operators. I'll go with my favourite (which is probably the less popular):
+-
+
Take a horizontal line on the lattice. On every qubit, apply $Z$. This is $Z_{1,L}$. In fact, any horizontal line is just as good.
+
+Take a vertical line on the lattice. On every qubit, apply $Z$. This is $X_{2,L}$ (the other convention would label it as $Z_{2,L}$)
+
+Take a horizontal strip of qubits, each of which is in the middle of a vertical edge. On every qubit, apply $X$. This is $Z_{2,L}$.
+
+Take a vertical strip of qubits, each of which is in the middle of a horizontal edge. On every qubit, apply $X$. This is $X_{1,L}$.
+
+
You'll see that the operators that are supposed to anti-commute meet at exactly one site, with an $X$ and a $Z$.
+Ultimately, we define the logical basis states of the code by +$$ +|\psi_{x,y}\rangle: Z_{1,L}|\psi_{x,y}\rangle=(-1)^x|\psi_{x,y}\rangle,\qquad Z_{2,L}|\psi_{x,y}\rangle=(-1)^y|\psi_{x,y}\rangle +$$
+The distance of the code is $N$ because the shortest sequence of single-qubit operators that converts between two logical states constitutes $N$ Pauli operators on a loop around the torus.
+Error Detection and Correction
+Once you have a code, with some qubits stored in the codespace, you want to keep it there. To achieve this, we need error correction. Each round of error correction comprises measuring the value of every stabilizer. Each $A_s$ and $B_p$ gives an answer $\pm 1$. This is your error syndrome. It is then up to you, depending on what error model you think applies to your system, to determine where you think the errors have occurred, and try to fix them. There's a lot of work going on into fast decoders that can perform this classical computation as efficiently as possible.
+One crucial feature of the Toric code is that you do not have to identify exactly where an error has occurred to perfectly correct it; the code is degenerate. The only relevant thing is that you get rid of the errors without implementing a logical gate. For example, the green line in the figure is one of the basic errors in the system, called an anyon pair. If the sequence of $X$ rotations depicted had been enacted, then the stabilizers on the two squares with the green blobs in would have given a $-1$ answer, while all others give $+1$. To correct this, we could apply $X$ along exactly the path where the errors happened, although our error syndrome certainly doesn't give us the path information. There are many other paths of $X$ errors that would give the same syndrome. We can implement any of these, and there are two options. Either, the overall sequence of $X$ rotations forms a trivial path, or one that loops around the torus in at least on direction. If it's a trivial path (i.e. one that forms a closed path that does not loop around the torus), then we have successfully corrected the error. This is at the heart of the topological nature of the code; many paths are equivalent, and it all comes down to whether or not these loops around the torus have been completed.
+Error Correcting Threshold
+While the distance of the code is $N$, it is not the case that every combination of $N$ errors causes a logical error. Indeed, the vast majority of $N$ errors can be corrected. It is only once the errors become of much higher density that error correction fails. There are interesting proofs that make connections to phase transitions or the random bond Ising model, that are very good at pinning down when that is. For example, if you take an error model where $X$ and $Z$ errors occur independently at random on each qubit with probability $p$, the threshold is about $p=0.11$, i.e. $11\%$. It also has a finite fault-tolerant threshold (where you allow for faulty measurements and corrections with some per-qubit error rate)
+The Planar Code
+Details are largerly identical to the Toric code, except that the boundary conditions of the lattice are open instead of periodic. This means that, at the edges, the stabilizers get defined slightly differently. In this case, there is only one logical qubit in the code instead of two.
+",1837,,4757,,6/13/2022 21:09,6/13/2022 21:09,,,,5,,,,CC BY-SA 4.0 +2124,2,,2105,5/21/2018 9:40,,3,,"Since you haven't told us how you've tried to do the calculation, I don't know where you're making the mistake. (I'm also unfamiliar with Quirk, which seems to be using an unusual ordering of basis elements in the output matrix. If anything looks inconsistent in the following answer, try swapping the middle two rows/columns, and adding a transpose!)
+ +The first important thing is to not use the percentage values in the transition matrices. These correspond to probabilities, but to do any further work, we need to know about probability amplitudes. So, the unitary output of your first sequence of gates is +$$ +\left( +\begin{array}{cccc} + \frac{\sqrt{2+\sqrt{2}}}{2} & \frac{1}{4} \left(-2+\sqrt{2}\right) & 0 & -\frac{i}{2 \sqrt{2}} \\ + 0 & \frac{1}{4} \left(2+\sqrt{2}\right) & -\frac{1}{2} i \sqrt{2-\sqrt{2}} & -\frac{i}{2 \sqrt{2}} \\ + 0 & -\frac{i}{2 \sqrt{2}} & \frac{\sqrt{2+\sqrt{2}}}{2} & \frac{1}{4} \left(-2+\sqrt{2}\right) \\ + -\frac{1}{2} i \sqrt{2-\sqrt{2}} & -\frac{i}{2 \sqrt{2}} & 0 & \frac{1}{4} \left(2+\sqrt{2}\right) \\ +\end{array} +\right) +$$ +Now we can apply the final sequence of gates; an $X$ on qubit 1, a controlled-$Y^{1/4}$ and another $X$ on qubit 1. You get the output unitary +$$ +\left( +\begin{array}{cccc} + \frac{1}{4} \left(2+\sqrt{2}\right) & -\frac{1}{2} \sqrt{1-\frac{1}{\sqrt{2}}} & -\frac{i}{2 \sqrt{2}} & + -\frac{1}{2} i \sqrt{\frac{1}{2} \left(2-\sqrt{2}\right)} \\ + 0 & \frac{1}{4} \left(2+\sqrt{2}\right) & -\frac{1}{2} i \sqrt{2-\sqrt{2}} & -\frac{i}{2 \sqrt{2}} \\ + -\frac{i}{2 \sqrt{2}} & -\frac{1}{2} i \sqrt{\frac{1}{2} \left(2-\sqrt{2}\right)} & \frac{1}{4} \left(2+\sqrt{2}\right) + & -\frac{1}{2} \sqrt{1-\frac{1}{\sqrt{2}}} \\ + -\frac{1}{2} i \sqrt{2-\sqrt{2}} & -\frac{i}{2 \sqrt{2}} & 0 & \frac{1}{4} \left(2+\sqrt{2}\right) \\ +\end{array} +\right) +$$ +The mod-square of each element is then +$$ +\left( +\begin{array}{cccc} + \frac{1}{16} \left(2+\sqrt{2}\right)^2 & \frac{1}{8} \left(2-\sqrt{2}\right) & \frac{1}{8} & \frac{1}{8} + \left(2-\sqrt{2}\right) \\ + 0 & \frac{1}{16} \left(2+\sqrt{2}\right)^2 & \frac{1}{4} \left(2-\sqrt{2}\right) & \frac{1}{8} \\ + \frac{1}{8} & \frac{1}{8} \left(2-\sqrt{2}\right) & \frac{1}{16} \left(2+\sqrt{2}\right)^2 & \frac{1}{8} + \left(2-\sqrt{2}\right) \\ + \frac{1}{4} \left(2-\sqrt{2}\right) & \frac{1}{8} & 0 & \frac{1}{16} \left(2+\sqrt{2}\right)^2 \\ +\end{array} +\right). +$$ +Numerically, these are the same as given in the question: +$$ +\left( +\begin{array}{cccc} + 0.729 & 0.0732 & 0.125 & 0.0732 \\ + 0 & 0.729 & 0.146 & 0.125 \\ + 0.125 & 0.0732 & 0.729 & 0.0732 \\ + 0.146 & 0.125 & 0 & 0.729 \\ +\end{array} +\right) +$$
+",1837,,,,,5/21/2018 9:40,,,,0,,,,CC BY-SA 4.0 +2125,2,,1999,5/21/2018 17:39,,3,,"One of many possible constructions that gives some insight into this question, at least to me, is as follows. Using the CSD (cosine-sine decomposition), you can expand any unitary operator into a product of efficient gates V that fit nicely into a binary tree pattern. In the case of the QFT, that binary tree collapses to a single branch of the tree, all the V not in the branch are 1.
+ + +",1974,,91,,08-07-2018 21:32,08-07-2018 21:32,,,,2,,,,CC BY-SA 4.0 +2126,1,,,5/21/2018 23:05,,12,545,"One deals with the notion of superposition when studying Shor's algorithm, but how about entanglement? Where exactly does it appear in this particular circuit?
+I assume it is not yet present in the initial state $\left|0\right>\left|0\right>$, but how about in further process, after applying Hadamard gates, the controlled-U gates and the inverse Fourier transform?
+I understand that the first and second registers have to be entangled, otherwise, the final measurement on one of them wouldn't collapse the other one, which gives us the period (well, kind of, we need to use continuous fractions to infer it).
+",1889,,55,,09-03-2021 11:37,09-03-2021 11:37,Where exactly does entanglement appear in Shor's algorithm?,Your question contains the answer, as you mention the controlled-U gate which is an entangling gate. You will see in the page I linked, that the action of c-U on $|+\rangle|0\rangle$ for example can turn the state into one which cannot be written as a product:
+ +$|+\rangle|0\rangle = \left( \frac{|0\rangle+|1\rangle}{\sqrt{2}} \right)\otimes |0\rangle = \left( \frac{|00\rangle+|10\rangle}{\sqrt{2}} \right)= \left( \frac{|00\rangle+|1\rangle U| +0\rangle}{\sqrt{2}} \right) = \left( \frac{|00\rangle+|1\rangle \left(u_{00}|0\rangle + u_{10}|1\rangle\right)}{\sqrt{2}} \right)$
+ +In the last step, I used the definition of $U$ from the linked controlled-U description:
+ +An example where this gate is entangling is where $u_{00}$ = 0 and $u_{10}=1$, which is just the $\rm{CNOT}$ gate. In that case we get $\frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)$ which is the Bell state and is maximally entangled.
+ +You may also be interested in this article on: ""Entanglement and it's role in Shor's algorithm"".
+",2293,,2293,,5/22/2018 0:04,5/22/2018 0:04,,,,2,,,,CC BY-SA 4.0 +2128,1,,,5/22/2018 10:14,,8,734,"The so-called depolarizing channel is the channel model that is mostly used when constructing quantum error correction codes. The action of such channel over a quantum state $\rho$ is
+$$\rho\rightarrow(1-p_x-p_y-p_z)\rho+p_xX\rho X+p_yY\rho Y+p_zZ\rho Z$$
+I was wondering which other channel models are considered in quantum communications, and how the construction of error correction codes is affected by considering such other channels.
+",2371,,55,,8/19/2020 10:15,8/19/2020 10:15,"What quantum channels are considered in quantum communication, and how does this choice affect the construction of error correction codes?",Is entanglement transitive, in a mathematical sense?
+ ++ +
More concretely, my question is this:
+ +Consider 3 qubits $q_1, q_2$ and $q_3$. Assume that
+ +-
+
- $q_1$ and $q_2$ are entangled, and that +
- $q_2$ and $q_3$ are entangled +
Then, are $q_1$ and $q_3$ entangled? If so, why? If not, is there a concrete counterexample?
+ ++ +
On my notion of entanglement:
+ +-
+
- qubits $q_1$ and $q_2$ are entangled, if after tracing out $q_3$, the qbits $q_1$ and $q_2$ are entangled (tracing out $q_3$ corresponds to measuring $q_3$ and discarding the result). +
- qubits $q_2$ and $q_3$ are entangled, if after tracing out $q_1$, the qbits $q_2$ and $q_3$ are entangled. +
- qubits $q_1$ and $q_3$ are entangled, if after tracing out $q_2$, the qbits $q_1$ and $q_3$ are entangled. +
Feel free to use any other reasonable notion of entanglement (not necessarily the one above), as long as you clearly state that notion.
+",2444,,26,,12/23/2018 12:28,12/23/2018 12:28,Is entanglement transitive?,I read the following in Freudenthal triple classication of three-qubit entanglement:
+ +""Dür et al. (Three qubits can be entangled in two inequivalent ways) used simple arguments concerning the conservation of ranks of reduced density matriceshere are only six three-qubit equivalence classes:
+ +-
+
- Null (The trivial zero entanglement orbit corresponding to vanishing states) +
- Separable (Another zero entanglement orbit for completely factorisable product states) +
- Biseparable (Three classes of bipartite entanglement: A-BC, B-AC, C-AB) +
- W (Three-way entangled states that do not maximally +violate Bell-type inequalities) and +
- GHZ (maximally violate Bell-type inequalities)"" +
which as I understand it the answer to your question is yes: if A and B are entangled and B and C are entangled you necessarily are in one of the three-way entangled states so A and C are also entangled.
+",1847,,,,,5/22/2018 18:00,,,,0,,,,CC BY-SA 4.0 +2131,2,,2129,5/22/2018 18:02,,12,,"TL;DR: It depends on how you choose to measure entanglement on a pair of qubits. If you trace out the extra qubits, then ""No"". If you measure the qubits (with the freedom to choose the optimal measurement basis), then ""Yes"".
+ ++ +
Let $|\Psi\rangle$ be a pure quantum state of 3 qubits, labelled A, B and C. We will say that A and B are entangled if $\rho_{AB}=\text{Tr}_C(|\Psi\rangle\langle\Psi|)$ is not positive under the action of the partial transpose map. This is a necessary and sufficient condition for detecting entanglement in a two-qubit system. The partial trace formalism is equivalent to measuring qubit C in an arbitrary basis and discarding the result.
+ +There's a class of counter-examples that show that entanglement is not transitive, of the form +$$ +|\Psi\rangle=\frac{1}{\sqrt{2}}(|000\rangle+|1\phi\phi\rangle), +$$ +provided $|\phi\rangle\neq |0\rangle,|1\rangle$. If you trace out qubit $B$ or qubit $C$, you'll get the same density matrix both times: +$$ +\rho_{AC}=\rho_{AB}=\frac12\left(|00\rangle\langle 00|+|1\phi\rangle\langle 1\phi|+|00\rangle\langle 1\phi|\langle\phi|0\rangle+|1\phi\rangle\langle 00|\langle0|\phi\rangle\right) +$$ +You can take the partial transpose of this (taking it on the first system is the cleanest): +$$ +\rho^{PT}=\frac12\left(|00\rangle\langle 00|+|1\phi\rangle\langle 1\phi|+|10\rangle\langle 0\phi|\langle\phi|0\rangle+|0\phi\rangle\langle 10|\langle0|\phi\rangle\right) +$$ +Now take the determinant (which is equal to the product of the eigenvalues). You get +$$ +\text{det}(\rho^{PT})=-\frac{1}{16}|\langle 0|\phi\rangle|^2(1-|\langle 0|\phi\rangle|^2)^2, +$$ +which is negative, so there must be a negative eigenvalue. Thus, $(AB)$ and $(AC)$ are entangled pairs. Meanwhile +$$ +\rho_{BC}=\frac12(|00\rangle\langle 00|+|\phi\phi\rangle\langle\phi\phi |). +$$ +Since this is a valid density matrix, it is non-negative. However, the partial transpose is just equal to itself. So, there are no negative eigenvalues and $(BC)$ is not entangled.
+ +Localizable Entanglement
+ +One might, instead, talk about the localizable entanglement. Before further clarification, this is what I thought the OP was referring to. In this case, instead of tracing out a qubit, one can measure it in a basis of your choice, and calculate the results separately for each measurement outcome. (There is later some averaging process, but that will be irrelevant to us here.) In this case, my response is specifically about pure states, not mixed states.
+ +The key here is that there are different classes of entangled state. For 3 qubits, there are 6 different types of pure state:
+ +-
+
- a fully separable state +
- 3 types where there is an entangled state between two parties, and a separable state on the third +
- a W-state +
- a GHZ state +
Any type of quantum state can be converted into one of the standard representatives of each class just by local measurements and classical communication between the parties. Note that the conditions of $(q_1,q_2)$ and $(q_2,q_3)$ being entangled remove the first 4 cases, so we only have to consider the last 2 cases, W-state and GHZ-state. Both representatives are symmetric under exchange of the particles: +$$ +|W\rangle=\frac{1}{\sqrt{3}}(|001\rangle+|010\rangle+|100\rangle)\qquad |GHZ\rangle=\frac{1}{\sqrt{2}}(|000\rangle+|111\rangle) +$$ +(i.e. if I swap qubits A and B, I still have the same state). +So, these representatives must have the required transitivity properties: If A and B are entangled, then B and C are entangled, as are A and C. In particular, Both of these representatives can be measured in the X basis in order to localize the entanglement. Thus, any pure state that you're given must be such that you can include the measurement to convert it into the standard representative into the measurement for localizing the entanglement, and you're done!
+",1837,,1837,,5/24/2018 4:00,5/24/2018 4:00,,,,5,,,,CC BY-SA 4.0 +2132,2,,2129,5/22/2018 18:07,,7,,"This isn't an answer, but instead just some background facts that are important to know about in order to avoid ""not even wrong"" territory on these types of questions.
+ +""Entanglement"" is not all-or-nothing. Just saying ""q1 is entangled with q2 and q2 is entangled with q3"" is not enough information to determine the answer to questions like ""if I measure q3, will q1 still be entangled with q2?"". Entanglement gets complicated when dealing with larger systems. You really need to know the specific state, and the measurement, and whether you are permitted to condition on the result of the measurement.
+ +It may be the case that q1,q2,q3 are entangled as a group but if you trace out any one of the qubits then the density matrix of the remaining two describes a mere classically correlated state. (E.g. this happens with GHZ states.)
+ +You should be aware of the monogamy of entanglement. Past a certain threshold, increasing the strength of the entanglement between q1 and q2 must decrease the strength of entanglement between q1 and q3 (and equivalently q2 and q3).
+",119,,119,,5/22/2018 18:09,5/22/2018 18:09,,,,2,,,,CC BY-SA 4.0 +2135,1,2136,,5/23/2018 15:42,,9,707,"Consider the measurement of the syndrome for the standard 3-qubit code to correct bit flips: +$$ +\def\place#1#2#3{\smash{\rlap{\hskip{#1px}\raise{#2px}{#3}}}} +\def\hline#1#2#3{\place{#1}{#2}{\rule{#3px}{1px}}} +\def\vline#1#2#3{\place{#1}{#2}{\rule{1px}{#3px}}} +% +\hline{30}{30}{210} +\hline{30}{60}{210} +\hline{30}{150}{210} +\hline{30}{180}{210} +\hline{30}{210}{210} +% +\vline{60}{60}{150} +\vline{90}{60}{120} +\vline{120}{30}{150} +\vline{150}{30}{120} +% +\place{46}{51}{\huge{\oplus}} +\place{76}{51}{\huge{\oplus}} +\place{106}{21}{\huge{\oplus}} +\place{136}{21}{\huge{\oplus}} +% +\place{30}{205}{\llap{Z_1}} +\place{30}{175}{\llap{Z_2}} +\place{30}{145}{\llap{Z_3}} +% +\place{241}{41}{\left. \rule{0px}{22.5px} \right\} M} +% +\phantom{\rule{280px}{225px}}_{\Large{.}} +$$
+ +Here $M$ is a measurement in the computational basis. This circuit measures $Z_1Z_2$ and $Z_2Z_3$ of the encoded block (i.e. the top three). My question is why measure these using ancilla qubits - why not just measure the 3 encoded qubits directly? Such a setup would mean you would not have to use c-not gates which from what I have heard are hard to implement.
+ +(Note I have only given this 3-qubit code as an example I am interested in general syndrome measurements on general codes).
+",2015,,1847,,6/15/2018 8:00,6/15/2018 8:00,Why do we use ancilla qubits for error syndrome measurements?,The key point of quantum error correction is precisely to correct the errors without collapsing the qubits, right? If we measure the encoded qubits we project the qubits to $\left|0\right>$ or $\left|1\right>$ and lose all the information in the coefficients $\alpha \left|0\right> + \beta \left|1\right>$. By measuring ancilla qubits we can know what has happened to the qubits without actually knowing the values of the qubits: this enables us to correct errors in a non-destructive way, and carry on with our quantum operation.
+",1847,,15,,5/24/2018 8:43,5/24/2018 8:43,,,,0,,,,CC BY-SA 4.0 +2137,2,,2097,5/23/2018 17:59,,3,,"This is a soft answer, offered b/c I'm interested in the etymologies of terms we use in math and science. For what it's worth:
+ +++ +entanglement (n.) + 1630s, ""that which entangles,"" from entangle + -ment. From 1680s as ""act of entangling."" Foreign entanglements does not appear as such in Washington's Farewell Address (1796), though he warns against them. The phrase is found in William Coxe's 1798 memoirs of Sir Robert Walpole. +
+
SOURCE: Online Etymological Dictionary
from:
+ +++ +tangle (n.) + 1610s, ""a tangled condition, a snarl of threads,"" from tangle (v.).
+
SOURCE: Online Etymological Dictionary
I make this connection because the idea of determinacy and strings/threads goes back to at least the ancient Greek Moirai (the Fates).
+",2447,,2293,,5/24/2018 4:38,5/24/2018 4:38,,,,3,,,,CC BY-SA 4.0 +2138,2,,2135,5/24/2018 4:09,,6,,"When you say ""why not just measure the 3 encoded qubits directly"", are you thinking that you could measure $Z_1$, $Z_2$ and $Z_3$, and that, from there, you can calculate the values $Z_1Z_2$ and $Z_2Z_3$?
+ +This is sort of true: if your only goal is to obtain the observables $Z_1Z_2$ and $Z_2Z_3$, you could do this.
+ +But that is not your end goal, which is, instead, to preserve the information encoded in the logical state. The only way you can do this is to learn nothing about the state that is encoded. Effectively, measuring in this way gives you too much information: it gives you 3 bits of information (1 bit from each measurement that you perform) when you only need 2 bits. Where does this extra bit come from? It is one bit of information about the state that you have encoded. In other words, you have measured the encoded state, destroying any superposition that you are specifically trying to use the error correcting code to protect.
+",1837,,,,,5/24/2018 4:09,,,,0,,,,CC BY-SA 4.0 +2139,2,,2097,5/24/2018 4:22,,6,,"According to Matthias Christandl (who did some research on this to resolve a bet with Artur Ekert), while the term ""entanglement"" was first used in 1935, as already relayed in other answers, the concept was discussed by Schrodinger in 1932. This set of slides (slides 3-8 in particular) from a talk reproduce part of a document that details this. The full image is also on the front of his thesis.
+",1837,,,,,5/24/2018 4:22,,,,0,,,,CC BY-SA 4.0 +2140,1,2141,,5/24/2018 7:57,,5,274,"In this pdf for the Simon's algorithm we need $n-1$ independent $\mathbf y$ such that: +$$ \mathbf y \cdot \mathbf s=0$$ +to find $\mathbf s$. On page 6 of the pdf the author writes that the probability of getting $n-1$ independent values of $\mathbf y$ in $n-1$ attempts is: +$$P_{\text{ind}}=(1-1/N(\mathbf s))(1-2/N(\mathbf s))\cdots (1-2^{n-1}/N(\mathbf s))\tag{1}$$ +where $N(\mathbf s)=2^{n-1}$ if $\mathbf s \ne 0$ and $2^n$ if $\mathbf s=0$. Clearly then $P_{\text{ind}}=0$ for $\mathbf{s}\ne 0$ - which I believe to be wrong.
+ +My question is, therefore: Is formula (1) wrong and if so what is the correct version. If it is not wrong how do we interpret +$P_{\text{ind}}=0$ .
+",2015,,26,,10/24/2019 13:23,10/24/2019 13:23,Simon's Algorithm Probability of Independence,At first glance, the formula looks lightly wrong: the last term in the should only be $(1-2^{n-2}/N(s))$, giving +$$ +P_{ind}=\prod_{k=1}^{n-1}\left(1-\frac{2^{k-1}}{N(s)}\right) +$$ +overall. Thus every term is a half, or larger.
+ +My reasoning is as follows: you perform a measurement and get a random outcome. The first time you do this, it can be any outcome except the all 0 string. This happens with probability $1-1/N(s)$.
+ +The second time, you want any string except the all zeros, or the answer you got last time, $y_1$. Thus, the term $1-2/N(s)$.
+ +The third time, you want any string except the all zeros, $y_1$, $y_2$ or $y_1\oplus y_2$. Thus, the term $1-4/N(s)$.
+ +Once you have $k-1$ linearly independent strings $y_1$ to $y_{k-1}$ and you're trying top find the $k^{th}$, there are $2^{k-1}$ answers you don't want to get: the $2^{k-1}$ answers that are linearly dependent on the strings you already have (note that this counting includes the all zeros string). You keep going until the last term, $k=n-1$ because you're trying to find $n-1$ linearly independent cases.
+ +Incidentally, this is not the way that I would ever make the argument. Who cares about the probability of needing exactly $n-1$ calls? You can just keep repeating as many times as you need to in order to find $n-1$ linearly independent strings. Since we've already argued that the worst-case probability of finding a new linearly independent string is 1/2, this means that, on average, no more than $2(n-1)$ trials would be required (and actually somewhat less, because early on you're far more likely to get a hit). You could also apply a Chernoff bound to prove that the probability of needing significantly more runs than that is vanishingly small. OK, that's essentially where the solution gets to, it just feels a little excessive (to me).
+",1837,,1837,,5/25/2018 7:00,5/25/2018 7:00,,,,0,,,,CC BY-SA 4.0 +2142,2,,1356,5/24/2018 15:37,,7,,"Classical Version
+ +Think about a simple strategy of classical error correction. You've got a single bit that you want to encode, +$$ +0\mapsto 00000\qquad 1\mapsto 11111 +$$ +I've chosen to encode it into 5 bits, but any odd number would do (the more the better). Now, let's assume some bit-flip errors have occurred, so what we have is +$$ +01010. +$$ +Was this originally the encoded 0 or 1? If we assume that the probability of error per bit, $p$, is less than a half, then we expect that fewer than half the bits have errors. So, we look at the number of 0s and the number of 1s. Whichever there's more of is the one that we assume is the one we started with. This is called a majority vote. There's some probability that we're wrong, but the more bits we encoded into, the smaller this probability.
+ +On the other hand, if we know that $p>\frac12$, we can still do the correction. You'd just be implementing a minority vote! The point, however, is that you have to do completely the opposite operation. There's a sharp threshold here that shows, at the very least, that you need to know which regime you're working in.
+ +For fault-tolerance, things get messier: the $01010$ string that you got might not be what the state actually is. It might be something different, still with some errors that you have to correct, but the measurements you've made in reading the bits are also slightly faulty. Crudely, you might imagine this turns the sharp transition into an ambiguous region where you don't really know what to do. Still, if error probabilities are low enough, or high enough, you can correct, you just need to know which is the case.
+ +Quantum Version
+ +In general, things get worse in the quantum regime because you have to deal with two types of errors: bit flip errors ($X$) and phase flip errors ($Z$), and that tends to make the ambiguous region bigger. I won't go further into details here. However, there's a cute argument in the quantum regime that may be illuminating.
+ +Imagine you have the state of a single logical qubit stored in a quantum error correcting code $|\psi\rangle$ across $N$ physical qubits. It doesn't matter what that code is, this is a completely general argument. Now imagine there's so much noise that it destroys the quantum state on $\lceil N/2\rceil$ qubits (""so much noise"" actually means that errors happen with 50:50 probability, not close to 100% which, as we've already said, can be corrected). It is impossible to correct for that error. How do I know that? Imagine I had a completely noiseless version, and I keep $\lfloor N/2\rfloor$ qubits and give the remaining qubits to you. We each introduce enough blank qubits so that we've got $N$ qubits in total, and we run error correction on them.
+
+If it were possible to perform that error correction, the outcome would be that both of us would have the original state $|\psi\rangle$. We would have cloned the logical qubit! But cloning is impossible, so the error correction must have been impossible.
I want to be able to applied controlled versions of the $R_y$ gate (rotation around the Y axis) for real devices on the IBM Q Experience. Can this be done? If so, how?
+",409,,26,,12/23/2018 13:51,12/23/2018 13:51,How can a controlled-Ry be made from CNOTs and rotations?,You can make controlled $R_y$ gates from cnots and $R_y$ rotations, so they can be be done on any pair of qubits that allows a cnot.
+ +Two examples of controlled-Ys are shown in the image below. They are on the same circuit, one after the other.
+ +The first has qubit 1 as control and qubit 0 as target, which is easy because the cnots can be directly implemented in the right direction.
+ +In the second example, qubit 0 is control and qubit 1 is target. This is achieved by using four H gates for each cnot to effectively turn it around.
+ +This second example can also be optimized further. There are two adjacent H gates on the top line that can be canceled. And since H anticommutes with Y, $H\,u3(\theta,0,0)\,H$ can always be replaced with $u3(-\theta,0,0)$. (Thanks to @DaftWullie for pointing these out).
+ +The single qubit gates used are $u3(\theta,0,0)$, which are $R_y(\theta)$ rotations. The angles used are pi/2 and -pi/2 in this case. These cancel when the control is $|0\rangle$. This gives the expected effect of the controlled-Y acting trivially in this case.
+ +When the control is $|1\rangle$, the cnots perform an X either side of the $u3(-\pi/2,0,0)$, which has the effect
+ +$X \, u3(\theta,0,0) \, X = u3(-\theta,0,0)$
+ +This means that the $u3(-\pi/2,0,0)$ flips to $u3(\pi/2,0,0)$. The end effect on the control is then
+ +$ u3(\pi/2,0,0) \, u3(\pi/2,0,0) \, = u\, 3(\pi,0,0) \, = \, Y$
+ +which is a $Y$
+ +A more general controlled $R_y$ rotation means that you want to do a fraction of a $Y$. So just reduce both angles by the corresponding fraction.
+",409,,409,,5/25/2018 11:40,5/25/2018 11:40,,,,5,,,,CC BY-SA 4.0 +2145,1,2146,,5/25/2018 14:20,,11,719,"I am a bit confused about the necessity of an oracle qubit in Grover's algorithm.
+ +My question is, does it depend on how you implement your oracle whether you need an oracle qubit or not? Or, it there any reason for an oracle qubit? (such as, there exist some problems that cannot be solved without an oracle qubit, or it's easier to think about the problem with an oracle qubit, or it's a convention, etc)
+ +Many resources introduce Grover's algorithm with an oracle qubit, but I found there are some cases that you do not need an oracle qubit.
+ +For example, here are two implementations of Grover's algorithm in IBM Q simulator. One is using an oracle qubit, and the other is not. In both cases, I would like to find |11> from a space of |00>, |01>, |10>, and |11>. In both cases, oracle successfully flips |11> to -|11>.
+ +・With an oracle qubit (Link to IBM Q simulator)
+
・Without an oracle qubit (Link to IBM Q simulator)
+
From the perspective of defining the quantum circuit, the oracle qubit is not strictly necessary. For example, in Grover's search, you might normally define the action of the oracle as +$$ +U|x\rangle|y\rangle=|x\rangle|y\oplus f(x)\rangle, +$$ +where $f(x)$ returns 1 if $x$ is the marked item. However, we always use this in a particular way, inputting $(|0\rangle-|1\rangle)/\sqrt{2}$ on the oracle qubit. This has the net effect of just implementing a phase on the marked item. In other words, it is entirely equivalent to the implementation of a new unitary +$$ +\tilde U|x\rangle=(-1)^{f(x)}|x\rangle +$$
+ +However, where it makes a difference is the practical reality. Searching for an item, we will actually need some sort of circuit that recognises the marked item, based on the input of $x$. At that point, it's far easier to think about outputting the answer onto the oracle bit, rather than somehow directly building the unitary that gives the phase without using the oracle qubit. Indeed, I suspect if I asked you to design a generic version $\tilde U$, you'd come up with $U$ with the extra qubit as the solution.
+",1837,,,,,5/25/2018 14:46,,,,3,,,,CC BY-SA 4.0 +2147,1,2148,,5/25/2018 17:48,,10,307,"Suppose I have a classical-classical-quantum channel $W : \mathcal{X}\times\mathcal{Y} \rightarrow \mathcal{D}(\mathcal{H})$, where $\mathcal{X},\mathcal{Y}$ are finite sets and $\mathcal{D}(\mathcal{H})$ is the set of density matrices on finite dimensional, complex Hilbert space $\mathcal{H}$.
+ +Suppose $p_x$ is the uniform distribution on $\mathcal{X}$ and $p_y$ is the uniform distribution on $\mathcal{Y}$. Further, define for distributions $p_1$ on $\mathcal{X}$ and $p_2$ on $\mathcal{Y}$, the Holevo information +$$\chi(p_1, p_2, W) := H\left(\sum_{x,y}p_1(x)p_2(y)W(x,y)\right) - \sum_{x,y}p_1(x)p_2(y)H(W(x,y))$$
+ +where $H$ is the von Neumann entropy.
+ +I would like to show, for +$$ p_1 := \sup_{p}\left\{ \chi(p, p_y, W)\right\}, p_2 := \sup_{p}\left\{ \chi(p_x, p, W)\right\}$$ +that, +$$\chi(p_1, p_2, W) \geq \chi(p_1, p_y, W) \text{ and } \chi(p_1, p_2, W)\geq \chi(p_x, p_2, W).$$
+ +So far, I'm not yet convinced that the statement is true in the first place. I haven't made much progress in proving this, but it seems like some sort of triangle inequality could verify the claim.
+ +Thanks for any suggestions regarding if the statement should hold and tips on how to prove it.
+",509,,55,,07-10-2021 23:33,07-10-2021 23:33,Proof of an Holevo information inequality for a classical-classical-quantum channel,It appears that the statement is not true in general. Suppose $X = Y = \{0,1\}$, $\mathcal{H}$ is the Hilbert space corresponding to a single qubit, and $W$ is defined as +\begin{align} +W(0,0) & = | 0 \rangle \langle 0 |,\\ +W(0,1) & = | 1 \rangle \langle 1 |,\\ +W(1,0) & = | 1 \rangle \langle 1 |,\\ +W(1,1) & = \frac{1}{2} | 0 \rangle \langle 0 | + \frac{1}{2} | 1 \rangle \langle 1 |. +\end{align} +If $p_y$ is the uniform distribution, the optimal choice for $p_1$ is $p_1(0) = 1$ and $p_1(1) = 0$, which gives $\chi(p_1,p_y,W) = 1$, which is the maximum possible value. (I assume you mean to define $p_1$ and $p_2$ as the argmax of those expressions, not the supremum.) Likewise, if $p_x$ is uniform, $p_2(0) = 1$ and $p_2(1) = 0$ is optimal, and the value is the same. However, $\chi(p_1,p_2,W) = 0$, so the inequality does not hold.
+",1764,,,,,5/25/2018 19:00,,,,0,,,,CC BY-SA 4.0 +2149,1,,,5/25/2018 20:59,,11,807,"I am confused about what to input to Oracle in Grover's algorithm.
+ +Don't we need to input what we are looking for and where to find what we are looking for to Oracle, in addition to the superpositioned quantum states?
+ +For example, assume we have a list of people's names {""Alice"", ""Bob"", ""Corey"", ""Dio""}, and we want to find if ""Dio"" is on the list. Then, Oracle should take $1/2(|00\rangle + |01\rangle + |10\rangle + |11\rangle)$ as an input and output $1/2(|00\rangle + |01\rangle + |10\rangle - |11\rangle)$. I kind of understand that.
+ +But don't we also need to input the word ""Dio"" and the list {""Alice"", ""Bob"", ""Corey"", ""Dio""} to Oracle? Otherwise, how can Oracle return output? Is it not explicitly mentioned since Oracle is a black box and we do not have to think about how to implement it?
+ +My understanding about Oracle is,
+ +-
+
- Oracle has the ability to recognize if the word ""Dio"" is in the list. +
- To do so, Oracle takes the superpositioned quantum states as an input, where each quantum state represents the index of the list. +
- So, input $|00\rangle$ to Oracle means, check if the word ""Dio"" is in the index 0 of the list and return $-|00\rangle$ if yes and return $|00\rangle$ otherwise. +
- In our case, Oracle returns $1/2(|00\rangle + |01\rangle + |10\rangle - |11\rangle)$. +
- But what about the list and the word? +
Although popular explanations of Grover's algorithm talk about searching over a list, in actuality you use it to search over possible inputs 0..N-1 to a function. The cost of the algorithm is $O(\sqrt{N} \cdot F)$ where $N$ is the number of inputs you want to search over and $F$ is the cost of evaluating the function. If you want that function to search over a list, you must hardcode the list into the function.
+ +Hard coding the function to use a list of $N$ items is usually a very bad idea, because it tends to cause $F$ to equal $O(N)$. Which would make the total cost of Grover's algorithm $O(\sqrt{N} \cdot F) = O(\sqrt{N} \cdot N) = O(N^{1.5})$. Which sort of defeats the whole purpose, since $N^{1.5} > N$.
+",119,,,,,5/25/2018 22:42,,,,4,,,,CC BY-SA 4.0 +2151,1,2152,,5/26/2018 23:24,,35,3876,"In the past few days, I have been trying to collect material (mostly research papers) related to Quantum machine learning and its applications, for a summer project. Here are a few which I found interesting (from a superficial reading):
+ +-
+
- Unsupervised Machine Learning on a Hybrid Quantum Computer (J.S. Otterbach et al., 2017) +
- Quantum algorithms for supervised and unsupervised machine learning (Lloyd, Mohseni & Rebentrost, 2013) +
- A Machine Learning Framework to Forecast Wave Conditions (James, Zhang & O'Donncha 2017) +
- Quantum Neuron: an elementary building block for machine learning on quantum computers (Cao, Guerreschi & Aspuru-Guzik, 2017) +
- Quantum machine learning for quantum anomaly detection (Liu & Rebentrost, 2017) +
However, coming from the more physics-y end of the spectrum, I don't have much +background knowledge in this area and am finding most of the specialized materials impenetrable. Ciliberto et al.'s paper: Quantum machine learning: a classical perspective somewhat helped me to grasp some of the basic concepts. I'm looking for similar but more elaborate introductory material. It would be very helpful if you could recommend textbooks, video lectures, etc. which provide a good introduction to the field of quantum machine learning.
+ +For instance, Nielsen and Chuang's textbook is a great introduction to the quantum computing and quantum algorithms in general and goes quite far in terms of introductory material (although it begins at a very basic level and covers all the necessary portions of quantum mechanics and linear algebra and even the basics of computational complexity!). Is there anything similar for quantum machine learning?
+ +P.S: I do realize that quantum machine learning is a vast area. In case there is any confusion, I would like to point out that I'm mainly looking for textbooks/introductory papers/lectures which cover the details of the quantum analogues of classical machine learning algorithms.
+",26,,55,,09-01-2020 22:27,08-09-2021 16:12,Introductory material for quantum machine learning,The Nielsen and Chuang of Quantum Machine Learning is this extensive review called ""Quantum Machine Learning"" published in Nature in 2017. The arXiv version is here and has been updated as recently as 10 May 2018.
+",2293,,1847,,5/27/2018 5:32,5/27/2018 5:32,,,,5,,,,CC BY-SA 4.0 +2154,1,,,5/27/2018 5:18,,7,134,"Could anyone point to some references examining Bell inequality violations at large distances please?
+I see many times, in pop science articles and research literature alike, that the quantum information of the entangled state is transmitted instantaneously to all components of the state. Strictly speaking, we must say that this is a theoretical prediction and provide an lower bound on the speed of information transfer from an experiment, right?
+",1867,,55,,2/22/2021 15:59,2/22/2021 15:59,References examining Bell inequality violations at large distances,If I have the $X$ gate acting on a qubit and the $\lambda_6$ gate acting on a qutrit, where $\lambda_6$ is a Gell-Mann matrix, the system is subjected to the Hamiltonian:
+$\lambda_6X= +\begin{pmatrix}0 & 0 & 0 & 0 & 0 & 0\\ +0 & 0 & 0 & 0 & 0 & 0\\ +0 & 0 & 0 & 0 & 0 & 1\\ +0 & 0 & 0 & 0 & 1 & 0\\ +0 & 0 & 0 & 1 & 0 & 0\\ +0 & 0 & 1 & 0 & 0 & 0 +\end{pmatrix} +$
+In case anyone doubts this matrix, it can be generated with the following script (MATLAB/octave):
+lambda6=[0 0 0; 0 0 1; 0 1 0];
+X= [0 1; 1 0 ];
+kron(lambda6,X)
+However consider the alternative Hamiltonian:
+$-\frac{1}{2}Z\lambda_1 + \frac{1}{2}\lambda_1 - \frac{1}{\sqrt{3}}X\lambda_8+\frac{1}{3}X$.
+This is the exact same Hamiltonian!
+The following script proves it:
+lambda1=[0 1 0;1 0 0;0 0 0];
+lambda8=[1 0 0;0 1 0;0 0 -2]/sqrt(3);
+Z= [1 0; 0 -1 ];
+round(-0.5*kron(Z,lambda1)+0.5*kron(eye(2),lambda1)-(1/sqrt(3))*kron(X,lambda8)+(1/3)*kron(X,eye(3)))
+The "round" in the last line of code can be removed, but the format will be uglier because some of the 0's end up being around $10^{-16}$.
+I thought the Pauli decomposition for two qubits is unique, why would the Pauli-GellMann decomposition of a qubit-qutrit be non-unique, and how would the decomposition $\lambda_6X$ from the above 6x6 matrix be obtained?
+",2293,,2293,,04-01-2021 22:34,04-01-2021 22:34,Why is the decomposition of a qubit-qutrit Hamiltonian in terms of Pauli and Gell-Mann matrices not unique?,Far from my expertise, but sheer curiosity. I've read that PostBQP (""a complexity class consisting of all of the computational problems solvable in polynomial time on a quantum Turing machine with postselection and bounded error"") is very powerful. Still, I don't understand the practical sense of assuming you can decide the value an output qubit takes.
+ +My question: Have post-selection quantum computing experiments been implemented (or is it possible that they will be implemented)? +(And, if the answer is yes: how does post-selection take place in a way that practically enhances your computing power?)
+",1847,,,,,5/27/2018 6:20,Is PostBQP experimentally relevant?,This looks essentially similar to the property of non-commutativity of the Kronecker product: $X\otimes \lambda_6\neq \lambda_6\otimes X$:
+ +$$X\otimes\lambda_6 = \begin{pmatrix}0&1 \\1&0\end{pmatrix}\otimes \begin{pmatrix}0&0&0 \\0&0&1 \\0&1&0\end{pmatrix} = +\begin{pmatrix}0&0&0&0&0&0 \\ +0&0&0&0&0&1\\ +0&0&0&0&1&0\\ +0&0&0&0&0&0\\ +0&0&1&0&0&0\\ +0&1&0&0&0&0 +\end{pmatrix}$$
+ +Unsurprisingly, you can't decompose $-\frac{1}{2}Z\lambda_1 + \frac{1}{2}I_2\lambda_1 - \frac{1}{\sqrt{3}}X\lambda_8+\frac{1}{3}XI_3 = \lambda_6X$ into $X\lambda_6$.
+ +However, as both matrices are square, they are 'permutation similar', so that $X\otimes \lambda_6=P^T\left(\lambda_6\otimes X\right)P$ for some permutation matrix $P$
+ +In other words, to answer part 1, for a given permutation/ordering, the decomposition is unique, but when the ordering is changed, the matrix/Hamiltonian undergoes a rotation $\left(P^T = P^{-1}\right)$, which also changes the decomposition.
+ +It becomes clear what can be used to decompose a matrix of this form by splitting it into sub-matrices: by writing $$X\lambda_6 = \begin{pmatrix}A&B\\C&D\end{pmatrix},$$ where each sub-matrix $A, B, C$ and $D$ is a $3\times 3$ matrix, it becomes clear that $A=D=0$ and $B=C=\lambda_6$, which verifies $$X\lambda_6 = \begin{pmatrix}0&\lambda_6\\\lambda_6&0\end{pmatrix} = X\otimes \lambda_6$$
+ +Performing the rotation/permuting and applying the same idea gives $$M=\begin{pmatrix}0&0&0&0&0&0 \\ +0&0&0&0&0&0\\ +0&0&0&0&0&1\\ +0&0&0&0&1&0\\ +0&0&0&1&0&0\\ +0&0&1&0&0&0 +\end{pmatrix} = \begin{pmatrix}A&B\\C&D\end{pmatrix},$$ which gives that $$A=0,\quad B=C=\begin{pmatrix}0&0&0\\0&0&0\\0&0&1\end{pmatrix},\quad D=\begin{pmatrix}0&1&0\\1&0&0\\0&0&0\end{pmatrix}=\lambda_1$$
+ +It follows that $B=C=\frac{1}{3}I_3-\frac{1}{\sqrt{3}}\lambda_8$, giving $$M=\begin{pmatrix}0&\frac{1}{3}I_3-\frac{1}{\sqrt{3}}\lambda_8\\\frac{1}{3}I_3-\frac{1}{\sqrt{3}}\lambda_8&\lambda_1\end{pmatrix}=\frac{1}{2}\left(I-Z\right)\otimes\lambda_1 + X\otimes\left(\frac{1}{3}I_3-\frac{1}{\sqrt{3}}\lambda_8\right).$$
+ +Changing the order of the decomposition: $$M=\begin{pmatrix}A&&B&&C\\D&&E&&F\\G&&H&&J\end{pmatrix},$$ which gives $A=B=C=D=E=G=J=0$ and $F=H=X$, in turn giving $$M=\begin{pmatrix}0&&0&&0\\0&&0&&X\\0&&X&&0\end{pmatrix}=\lambda_6\otimes X$$
+",23,,23,,5/28/2018 23:16,5/28/2018 23:16,,,,3,,,,CC BY-SA 4.0 +2158,2,,2154,5/27/2018 11:11,,3,,"The largest scale Bell test done thus far is the ""Cosmic Bell Test"" of 2017. It ruled out hidden variables within a distance of 600 light years from Earth.
+ +The 16 significant Bell test experiments performed between 1972 and 2018 are listed here with references to the original papers.
+",2293,,,,,5/27/2018 11:11,,,,2,,,,CC BY-SA 4.0 +2159,1,2160,,5/27/2018 11:21,,8,304,"The Pauli group, $P_n$, is given by +$$P_n=\{ \pm 1, \pm i\}\otimes \{ I,\sigma_x,\sigma_y,\sigma_z\}^{\otimes n}$$ +Abelian subgroups of this which do not contain the element $(-1)*I$ correspond to a stabilizer group. If there are $r$ generators of one such subgroup, $\mathcal{G}$, then the $+1$ eigenstate has $2^{n-r}$ basis elements.
+ +This then leads to the natural question of whether we have that $r\le n$ and how can it be proved (either way)?
+ +I guess a (valid?) proof would be along the lines of that if $r \gt n$ we would have a bias of fractional dimension - this is not allowed so $r\lt n$. But if one exists I would prefer a proof considering only the group properties and not the space which it acts on.
+",2015,,,,,5/27/2018 14:25,Maximum number of Stabilizer Generators?,Consider a subgroup $G $ of the Pauli group with at least one operator that acts non-trivially on some qubit.
+ +-
+
Given any qubit $j $, for which the group contains an operator $S_j $ which acts on $j $ non-trivially, there is a Clifford group operator $C_j $ such that $C_j S_j C_j^\dagger =Z_j $, acting on qubit $j $ alone. (Why?)
+If $G_j = \{ C_j S C_j^\dagger \,\vert\, S \in G \}$ and $G $ is abelian, then $G_j = \langle Z_j \rangle \oplus G'_j$, where $G'_j $ does not act on qubit $j $. (Why?)
+By induction, we can transform any abelian subgroup on $n $ qubits to a group with at most $n+1$ generators, where up to $n $ of them act on a single qubit with a $Z $ operator. (And what then would the remaining one be?)
+
From this, we can prove that a stabiliser group on $n $ qubits has at most $n $ generators; and with only a little more work, we can show that a stabiliser group with $r $ generators stabilises a subspace of dimension $2^{n-r} $.
+",124,,,,,5/27/2018 14:25,,,,0,,,,CC BY-SA 4.0 +2161,1,2183,,5/27/2018 14:57,,12,780,"According to An introduction to quantum machine learning (Schuld, Sinayskiy & Petruccione, 2014), Seth Lloyd et al. say in their paper: Quantum algorithms for supervised and unsupervised machine learning that classical information can be encoded into the norm of a quantum state $\langle x|x \rangle = |\vec{x}|^{-1}\vec{x}$. I'm not sure I understand their notation.
+ +Let's take a simple example. Say I want to store this array: $V = \{3,2,1,2,3,3,5,4\}$ of size $2^{3}$ in the state of an $3$-qubit quantum system.
+ +I can represent the state of an $3$-qubit system as:
+ +$|\psi\rangle = a_1|000\rangle + a_2|001\rangle + a_3|010\rangle + a_4|011\rangle + a_5|100\rangle + a_6|101\rangle + a_7|110\rangle + a_8|111\rangle$ (using standard basis) where $a_i\in \Bbb C \ \forall \ 1 \leq i\leq 8$.
+ +I could represent $V$ as a vector $\vec{V} = 3 \hat{x}_1 + 2 \hat{x}_2 +... + 4 \hat{x}_8$ where $\{\hat{x}_1,\hat{x}_2,...,\hat{x}_8\}$ forms an orthonormal basis in $\Bbb R^{8}$, and write the standard Euclidean norm for it as $|\vec{V}|=\sqrt{3^2+2^2+...+4^2}$.
+ +After this, I'm confused as to how I'd get the coefficients $a_1,a_2,..,a_8$. Should I just assign $3$ to $a_1$, $2$ to $a_2$ and so on?
+ +But, then again:
+ +++ +Consider the vector $N=2^{n}$ dimensional complex vector $\vec{v}$ + with components $\{v_i=|v_i|e^{i\phi_i}\}$. Assume that + $\{|v_i|,\phi_i\}$ are stored as floating point numbers in quantum + random access memory. Constructing the $\log_2 N$ qubit quantum state + $|v\rangle = |\vec{v}|^{-1/2}\vec{v}$ then takes $\mathcal{O}(\log_2 + N)$ steps as long as the sub-norms are also given in the qRAM in which + case any state can be constructed in $\mathcal{O}(\log N)$ steps.
+
Firstly, I don't understand their notion of a $2^n$ dimensional complex vector. If each of the components of their classical data array has two floating point numbers, wouldn't encoding that into a $n$-qubit quantum state be equivalent to storing a $2\times 2^{n}$ size classical array in a $n$-qubit system? Yes, I do know that $a_1,a_2,..,a_{2^n}$ are complex numbers having both magnitude and direction, and hence can store $2\times 2^{n}$ amount of classical information. But they don't mention anywhere how they will convert classical data (say in form of a $2\times 2^{n}$ array) into that form. Moreover, there seems to be a restriction that phase of a complex number $a_i$ can only range from $-\pi$ to $+\pi$.
+ +Secondly, let us assume that the initial data array we wanted to store in our quantum system was actually $V=\{\{3,\phi_1\},\{2,\phi_2\},...,\{4,\phi_8\}\}$.
+ +If they define $|v\rangle$ as $|\vec{v}|^{-1/2}\vec{v}$ then $|V\rangle$ in our example would look something like $(\sqrt{3^2+2^2+...+4^2})^{-1/2}(|3e^{i\phi_1}||000\rangle + |2e^{i\phi_2}||001\rangle + ... + |4e^{i\phi_8}||111\rangle)$. But then we're losing all the information about the phases $\phi_i$, isn't it? So what was the use of starting with a complex vector (having both a phase and magnitude) in the first place, when we're losing that information when converting to $|V\rangle$ anyway? Or are we writing supposed to consider $|V\rangle$ as $(\sqrt{3^2+2^2+...+4^2})^{-1/2}(3e^{i\phi_1}|000\rangle + 2e^{i\phi_2}|001\rangle + ... + 4e^{i\phi_8}|111\rangle)$?
+ +It would be really helpful if someone could explain where I am going wrong using some concrete examples regarding storage of classical data in an $n$-qubit system.
+",26,,55,,2/20/2021 16:25,2/20/2021 16:25,Embedding classical information into norm of a quantum state,I am getting confused about Grover's algorithm and it's connection to complexity classes.
+ +The Grover's algorithm finds and element $k$ in a database of $N=2^n$ (such that $f(k)=1$) of elements with $$\sim \sqrt{N}=2^{n/2}$$ +calls to the oracle.
+ +So we have the following problem:
+ +++ +Problem: Find a $k$ in the database such that $f(k)=1$
+
Now I am aware that this is not a desision problem and thus our normal definitions of complexity class $\text{P}$, $\text{NP}$ etc don't really apply. But I am curious to know how we would define the complexity class in such a case - and weather it is done with respect to $N$ or $n$?
+ +Furthermore the Grover's algorithm can be used as a subroutine. I have read in several places that the Grover's algorithm does not change the complexity class a problem - is there a heuristic way to see this.
+",2015,,1837,,5/28/2018 14:07,06-02-2018 06:07,Grover's Algorithm and its relation to complexity classes?,Forget about database. Grover's algorithm solves Boolean Satisfiability Problem, namely:
+ +You have a boolean circuit with $n$ inputs and a single output. The circuit outputs $1$ for a single configuration of input bits, otherwise is outputs $0$. Find the configuration of input bits.
+ +The problem is known to be NP-complete.
+",2105,,,,,5/27/2018 16:20,,,,3,,,,CC BY-SA 4.0 +2170,2,,2154,5/28/2018 8:25,,5,,"I think there is a conceptual thing going on here that needs clarifying (I'll leave the experimental links to others). I presume the question is predicated on the idea that, well, measurements are made within a certain time of each other, which is compared to the distance between the places where the measurements are being made. The concern is that this only gives a bound: if information is transmitted, it happens faster than some velocity which we have now bounded.
+ +However, what one ought to do is consider what special relativity tells you: if two events are space-like separated, there is no notion of temporal ordering. Different observers, travelling at different velocities, can see the events happening in different orders (or simultaneously). So, all you need to know is that the measurement events are space-like separated (i.e. the distance between the events is larger than speed of light $\times$ time between events), and that is enough.
+ +Also, there's a terminology issue. Bell tests do not talk about the transmission of information, but the presence of correlation. The term information would suggest that one party can choose some information to communicate to another party. This cannot happen faster than the speed of light. But the ""random decision"" made when a measurement is made on an entangled state is somehow resolved everywhere simultaneously, but does not communicate any information.
+",1837,,,,,5/28/2018 8:25,,,,2,,,,CC BY-SA 4.0 +2171,2,,1648,5/28/2018 13:39,,3,,"There has been a great deal of scientific debate over evidence of quantum effects in biology due to the difficulties of reproducing scientific evidence. Some have found evidence of quantum coherence while others have argued this is not the case. (Ball, 2018).
+ +The most recent research study (in Nature Chemistry, May 2018) found evidence of a specific oscillating signal indicating superpositioning. The scientists found quantum effects that lasted precisely as expected based on theory and proved that these belong to energy superimposed on two molecules simultaneously. This resulted in the conclusion that biological systems exhibit the same quantum effects as non-biological systems.
+ +These effects have been observed in the Fenna-Matthews-Olsen reaction centre of the bacteria - Chlorobium Tepidum (Borroso-Flores, 2017).
+ +Research evidences the dimensions and time scales of the photosynthetic energy transfer processes puts them close to the quantum/classical border. There are various explanations for this, but they seem to indicate energetically noisy quantum/classical limit is ideal for excitation energy transfer control. Keren 2018.
+ +Quantum Biology as Biological Semiconductors
+ +++ + + +Such dynamics in biology rely on spin chemistry (radical pairs), and + it is has been recognised that “Certain organic semiconductors (OLEDs) + exhibit magnetoelectroluminescence or magnetoconductance, the + mechanism of which shares essentially identical physics with radical + pairs in biology”
+
The terms 'spin singlets' and 'triplets' are used in spintronics (in investigating semiconductors) and the term radical pairs (including spin singlets or triplets) are used to discuss spin chemistry in biology. But all the terms are describing the same phenomena (just in different disciplinary realms). Recently there has been interdisciplinary calls for the integration of spin chemistry and spintronics in recognition of this J Matysik (2017).
+ +Biological semiconductors that have already identified by scientists include melanin and peptides, and peptides are now being explored as scaffolds for quantum computing.
+ +UltriaFast Electron Transfer, and Storing Electronic Spin Information in a Nuclear Spin
+ +++ +During photosynthesis, plants use electronic coherence for ultrafast + energy and electron transfer and have selected specific vibrations to + sustain those coherences. In this way photosynthetic energy transfer + and charge separation have achieved their amazing efficiency. At the + same time these same interactions are used to photoprotect the system + against unwanted byproducts of light harvesting and charge separation + at high light intensities
+
Rienk van Grondelle.
+ +In charge separation in photosynthetic reaction centres, triplet states can react with molecular oxygen generating destructive singlet oxygen. The triplet product yield in bacteria and plants is observed to be reduced by weak magnetic fields. It has been suggested that this effect is due to solid-state photochemically induced dynamic nuclear polarization (photo-CIDNP), which is an efficient method of creating non-equilibrium polarization of nuclear spins by using chemical reactions, which have radical pairs as intermediates (Adriana Marais 2015). Within biology such as mechanism could increase resistance to oxidative stress.
+ +It has been noted there seems to be a link between the conditions of occurrence of photo-CIDNP in reaction centres and the conditions of the unsurpassed efficient light-induced electron transfer in reaction centres. J Matysik 2009, I F Cespedes-Camacho and J Matysik 2014.
+ +A CIDNP effect has been observed in the Fenna-Matthews-Olsen reaction centre (Roy et al 2006).
+ +A CIDNP effect has also been observed in flavin adenine dinucleotide (FAD) (Stob 1989).
+ +FAD is implicated in quantum effects theorised in cryptochrome and other biological redox reactions. The widely accept theory is that during response to magnetic fields, the photo-excitation of the non-covalently bound flavin adenine dinucleotide (FAD) cofactor in Cryptochrome leads to the formation of radical pairs via sequential electron transfers along the “tryptophan-triad”, a chain of three conserved tryptophan residues within the protein. This process reduces the photo-excited singlet state of the FAD to the anion radical, +In the same way that photo-CIDNP MAS NMR has provided detailed insights into photosynthetic electron transport in reaction centres, it is anticipated in a variety of applications in mechanistic studies of other photoactive proteins. It may be possible to characterize the photoinduced electron transfer process in cryptochrome Xiao-Jie (2016).
+ +++ + +",2498,,,,,5/28/2018 13:39,,,,1,,,,CC BY-SA 4.0 +2172,1,,,5/28/2018 16:16,,6,449,"'until now, no CIDNP phenomenon has been observed in spintronics , + although the possibility of obtaining such effects has been + mentioned “If nuclear spin resonance is found to have an impact on the + spin-dependent electron transport due to the hyperfine interaction, + ultimately the opposite process may become possible: storing + electronic spin information in the nuclear spin.”
+
The image is taken from this link.
+ +
+Here Alice is using random bases to encode 0 or 1. After the process is completed, Bob has similarly polarized photons as Alice. These polarization can be any of the $\lvert 0 \rangle , \lvert 1 \rangle, \lvert + \rangle$ or $\lvert - \rangle$. However, how would Bob know what Alice meant for which two of these bases? Meaning, Alice might choose ${\lvert 0 \rangle, \lvert + \rangle}$ to encode a 0 and ${\lvert 1 \rangle, \lvert - \rangle}$ to encode a 1 or vice versa. How do they determine which polarization encodes which bits?
That’s the public discussion stage: Alice and Bob can both announce which basis they chose for each round. If they happened to pick the same basis on a given round, they know that (in a perfect world) their answers were the same, so they can translate them into a 0/1 value that nobody else knows. That translation is arbitrary, and they’ve probably agreed it in advance.
+ +The natural way to do this is to associate an operator with each measurement basis, e.g. X or Z (the Pauli matrices). The measurement answers are then e.g. $(\mathbb{I}+(-1)^xX)/2$ where x is a bit value which we use as the translation.
+",1837,,1837,,5/28/2018 18:24,5/28/2018 18:24,,,,2,,,,CC BY-SA 4.0 +2174,1,,,5/28/2018 18:47,,4,552,"I recently asked this question on Grover's algorithm, and I am still fairly confused about the whole thing. Consider the following snippet from this post (written by DIDIx13) which for convenience I will reproduce here:
+ +++ +If you throw away the problem structure, and just consider the space of $2^n$ possible solutions, then even a quantum computer needs about $\sqrt{2^n}$ steps to find the correct one (using Grover's algorithm) + If a quantum polynomial time algorithm for a $\text{NP}$-complete problem is ever found, it must exploit the problem structure in some way.
+
The first line emphasis one place where I am confused: Grover's algorithm finds a solution amongst $2^n$ solutions to a problem - this is not a decisions problem alone and as mentioned in my question linked above means we cannot assign it a complexity class.
+ +That said Grover's algorithm can be used to solve decision problems (there seems to be a lot of talk on related questions about ""SAT"") - but I have yet seen a simple example of such an application.
+ +Thus my question is: Does there exist a simple example of Grover's algorithm solving a decision problem? (even better if you can provide one where the classical search is in $NP$ and another in $P$)
+",2015,,,,,06-02-2018 06:53,Example of Grover's Algorithm applied to a decision problem?,Take the problem of 3-SAT. There is some $f(x)$ which gives outputs 0 or 1. We generally think of the case where the outputs 1 are rare, and hard to find.
+ +PROBLEM: Determine if there is an $x$ that satisfies $f(x)=1$.
+ +(3-SAT has a certain structure to the way the variables are evaluated based on conjunctive normal form, but that's not so important right now).
+ +This problem is known to be NP-complete: as much as we believe NP and P are distinct, we believe this problem cannot be solved efficiently. But Grover's does help us because it gives us a square root speed-up; it searches for the items where the answer is 1.
+ +I'm not sure if you're asking for a specific example of an $f(x)$, but one of the issues is that this complexity classification is about scaling: you need a family of functions for different sized inputs. 3-SAT is one such class. Perhaps my answer here supplies the sorts of examples you were after?
+",1837,,1837,,06-02-2018 06:53,06-02-2018 06:53,,,,0,,,,CC BY-SA 4.0 +2176,1,,,5/28/2018 20:45,,5,194,"In the paper ""Demonstration of two-qubit algorithms with a superconducting quantum processor"" (L. DiCarlo et al., Nature 460, 240 (2009), arXiv) they demonstrate how to realize conditional phase gates with superconducting qubits.
+ +Specifically, they use the $|{1,1}\rangle \leftrightarrow |0, 2\rangle$ to create a conditional phase gate. I quote ""his method of realizing a +C-Phase gate by adiabatically using the avoided crossing between +computational and non-computational states is generally applicable +to qubit implementations with finite anharmonicity, such as trans- +mons or phase qubits"".
+ +My question is how this technique works, especially why it is a controlled gate.
+",1853,,1847,,5/29/2018 2:33,5/29/2018 10:52,Conditional Phase Gate Superconducting Qubits,I want to create a Toffoli gate controlled by n qubits, and implement it in QISKit. Can this be done? If so, how?
+",2503,,26,,03-12-2019 09:30,01-06-2022 11:04,How can I implement an n-bit Toffoli gate?,A simple way to do this is illustrated in Figure 4.10 of Nielsen & Chuang.
+
Where U can be any single-qubit rotation (in this case, an X gate).
+ +This circuit works like this: +We want to apply U to the target qubit only if the AND of all control qubits is 1. A normal Toffoli gives us the AND of 2 qubits. So by chaining a few Toffolis, we can get c1.c2.c3.c4.c5, with the catch that some ""work"" (or ancilla) qubits have been introduced to store intermediate results. After applying the final CU, we get the final result in target. Now we can clean up the intermediate work qubits by undoing their computations, returning them to the |0> state. +This model of reversible computation is known as the ""compute-copy-uncompute"" method, and was first proposed by Charlie Bennett in 1973.
+ +Here is the QISKit code to construct the circuit and visualize it:
+ + + +from qiskit import QuantumRegister, QuantumCircuit
+
+n = 5 # must be >= 2
+
+ctrl = QuantumRegister(n, 'ctrl')
+anc = QuantumRegister(n-1, 'anc')
+tgt = QuantumRegister(1, 'tgt')
+
+circ = QuantumCircuit(ctrl, anc, tgt)
+
+# compute
+circ.ccx(ctrl[0], ctrl[1], anc[0])
+for i in range(2, n):
+ circ.ccx(ctrl[i], anc[i-2], anc[i-1])
+
+# copy
+circ.cx(anc[n-2], tgt[0])
+
+# uncompute
+for i in range(n-1, 1, -1):
+ circ.ccx(ctrl[i], anc[i-2], anc[i-1])
+circ.ccx(ctrl[0], ctrl[1], anc[0])
+
+from qiskit.tools.visualization import circuit_drawer
+circuit_drawer(circ)
+Yields:
+ +Each of the two spins, $q\in\{L,R\}$, has a bunch of energy levels $\{|n\rangle_q\}$, each at energy $\omega_{n}^q$. In other words, the basic Hamiltonian of the spins is: +$$ +H=\sum_{n=0}^{N}\omega_{n}^L|n\rangle\langle n|_L+\omega_{n}^R|n\rangle\langle n|_R +$$ +Written like this, the two spins are not interacting, so we won't get a two-qubit gatewithout doing something extra.
+ +We we're talking about a qubit, we specifically focus on populating just the $|0\rangle$ and $|1\rangle$ levels of each spin. Nothing else is ever populated (hopefully). Under the Hamiltonian $H$, as basis element $|x\rangle$ for $x\in\{0,1\}^2$ acquires a phase +$$ +e^{-i(\omega^L_{x_L}+\omega^R_{x_R})t}. +$$
+ +In addition to this basic Hamiltonian of the spins, there is a cavity, containing photons that interact with both spins. This is what will mediate the two-qubit interaction. In effect, by manipulating the interaction parameters, we can change the energy level of the $|1\rangle_L|1\rangle_R$ state independently of the $|10\rangle$ and $|01\rangle$ states. Thus, in principle, one creates a different phase pno all 4 basis states, and these can be combined to give a controlled-phase gate.
+ +In practice, how this works is that most of the time you want to be sat in a region of parameter space where there is no two-qubit interaction going on. At particular moments of a computation, you need to turn this interaction on. This is achieved by adiabatically varying the cavity parameters. By doing this, the populations of the qubits in the different basis states don't change, but you move to a regime where the energy levels are different, and generating the phases you need.
+ +You'll notice I haven't mentioned the $|0,2\rangle$ level yet. In some ways this is irrelevant; everything I've said is (a sufficiently good approximation to) true. The issue is that usually, when you change the parameters, you don't get the independent control of the different energies. The place to go looking, if you want to find such independent control, is in the region of an 'avoided crossing', where the usual linear variation of energy with parameters would suggest that two energy levels should be the same (e.g. the $|11\rangle$ and $|02\rangle$ levels). The avoided crossing means that the energy takes on a quadratic form near the (not) crossing point, and it's that non-linearity that you're making use of. It also defines important constraints on the adiabatic evolution: since you do not want to populate the $|02\rangle$ level, you have to move slowly with respect to the energy gap between $|11\rangle$ and $|02\rangle$, which is comparatively small, and therefore the evolution time is quite slow.
+",1837,,,,,5/29/2018 10:52,,,,0,,,,CC BY-SA 4.0 +2182,1,2184,,5/29/2018 14:59,,6,183,"I know there are some ""quantum versions"" of hand-writing recognition algorithms which have been proposed using quantum neural networks. Example: ""Recognition of handwritten numerals by Quantum Neural Network with fuzzy features"" (J Zhou, 1999). Also, recently by Rebentrost et al.: ""A Quantum Hopfield Neural Network"" presents an application of their method as a genetic sequence recognizer.
+ +What are some other proposed applications of quantum neural networks whose given solutions provide considerable improvement over the corresponding classical version of the neural network in terms of accuracy? Also, have any of those proposed solutions been programmed/simulated?
+ +Please note that I'm looking for research papers which specifically demonstrate some applications of quantum neural networks and which provide a significant improvement over the corresponding classical neural networks.
+",26,,26,,5/31/2018 23:22,5/31/2018 23:22,What are some of the interesting problems whose solutions have been proposed using quantum neural networks?,++ +I don't understand their notion of a $2^n$ dimensional complex + vector. If each of the components of their classical data array has + two floating point numbers, wouldn't encoding that into a $n$-qubit + quantum state be equivalent to storing a $2\times 2^{n}$ size + classical array in a $n$-qubit system?
+
You are absolutely correct that a $2\times 2^n$ classical array of nubers is stored in an n-qubit system.
+ +But they are absolutely right that the vector's dimension is $2^n$. This is because the vector has $2^n$ rows, where each entry has 2 classical numbers.
+ +You can also store the same vector in a $2\times 2^n$ array: $2^n$ rows are filled in with the real parts and $2^n$ rows by the imaginary parts, but this vector would not evolve according to the Schrödinger equation.
+ +I hope this helps resolve this part of the question.
+ +++ +But they don't mention anywhere how they will convert classical data (say in form of a $2\times 2^{n}$ array) into that form.
+
You are right. Just as Peter Shor never mentioned anywhere how his qubits for factoring will be prepared.
+ +This is up to the experimentalists, and it is implementation-dependent. This means that for NMR qubits you'd convert the classical data into qubits differently from superconducting qubits, or ion-trap qubits, or quantum dot qubits, etc. Therefore I do not blame Shor, or any of the 6 authors of the 2 papers you mentioned (who are all theorists by the way), for not explaining how the qubits will be prepared.
+ +++ +let us assume that the initial data array we wanted to store in our quantum system was actually $V=\{\{3,\phi_1\},\{2,\phi_2\},...,\{4,\phi_8\}\}$. If they define $|v\rangle$ as $|\vec{v}|^{-1/2}\vec{v}$ then $|V\rangle$ in our example would look something like $(\sqrt{3^2+2^2+...+4^2})^{-1/2}(|3e^{i\phi_1}||000\rangle + |2e^{i\phi_2}||001\rangle + ... + |4e^{i\phi_8}||111\rangle)$. But + then we're losing all the information about the phases $\phi_i$, isn't + it? So what was the use of starting with a complex vector (having + both a phase and magnitude) in the first place, when we're losing that + information when converting to $|V\rangle$ anyway?
+
You had it earlier in your question! ""Consider the vector $N=2^{n}$ dimensional complex vector $\vec{v}$ with components $\{v_i=|v_i|e^{i\phi_i}\}$."" Therefore the vector is:
+ +\begin{equation} +|\vec{v}|^{-1/2} +\begin{pmatrix}|v_{1}|e^{i\phi_{1}}\\ +|v_{2}|e^{i\phi_{2}}\\ +\vdots\\ +|v_{2^{n}}|e^{i\phi_{2^{n}}} +\end{pmatrix} +\end{equation}
+ +Notice:
+1) There's $2^n$ entries, not $2 \times 2^n$
+2) There is NO norm around the phases, so this is why you have lost all information about the phases, because you put extra norm symbols where they shouldn't be :)
++ +Or are we writing supposed to consider $|V\rangle$ as + $(\sqrt{3^2+2^2+...+4^2})^{-1/2}(3e^{i\phi_1}|000\rangle + + 2e^{i\phi_2}|001\rangle + ... + 4e^{i\phi_8}|111\rangle)$?
+
Closer! The correct answer is the vector I wrote above, which can be written like this:
+ +$|\vec{v}|^{-1/2}\left( e^{i \phi_1} |00 \cdots 00\rangle + e^{i \phi_2} |00 \cdots 01\rangle + \cdots + e^{i \phi_{N}} |1\cdots 1\rangle\right)$.
+ +For your specific example:
+ +\begin{equation} + \frac{3e^{i\phi_1}|000\rangle + 2e^{i\phi_8}|001\rangle + \cdots + 4e^{i\phi_8}|111\rangle}{\sqrt{77}} +\end{equation}
+ +The purpose of all of this is so that the sum of the squares of the coefficients is 1, which in my equation is true because the numberator is:
+ +\begin{equation} +\sqrt{3^2 + 2^2 + 1^2 + 2^2 + 3^2 + 3^2 + 5 ^2+ 4^2} = \sqrt{77} +\end{equation}
+ +I hope that clears it up!
+",2293,,26,,5/29/2018 18:02,5/29/2018 18:02,,,,6,,,,CC BY-SA 4.0 +2184,2,,2182,5/29/2018 17:19,,2,,"++ +What are some other proposed applications of quantum neural networks?
+
Absolutely any application of classical neural networks can be an application of quantum neural networks. There's a lot of examples beyond the two you listed.
+ +++ +Also, have any of those proposed solutions been programmed/simulated?
+
Yes, for example Ed Farhi of MIT and Hartmut Neven of Google teamed up on a paper where an application was distinguishing digits using QNNs.
+",2293,,,,,5/29/2018 17:19,,,,3,,,,CC BY-SA 4.0 +2185,2,,2166,5/29/2018 18:34,,2,,"All counting is done in terms of $n$, the number of bits required to describe the input.
+ +We define the class of problems $\text{NP}$ in the following way (or, this is one way to do it):
+ +Let $f(x)$ be a function that accepts an input $x\in\{0,1\}^n$ and returns a single bit value 0 or 1. The task is that you have to find whether a given value of $x$ returns a 1. However, there is further structure to the problem: if $f(x)=1$, you are guaranteed that there exists a proof $p_x$ (of size $m\sim\text{poly}(n)$) such that a function $g(x,p_x)=1$ only if $f(x)=1$, and the function $g(x,p_x)$ is efficiently computable (i.e. it has a running time of $\text{poly}(n)$.
+ +Let me give a few examples (perhaps these are what you were asking for here?):
+ +-
+
Parity: $f(x)$ answers the question 'is $x$ odd?'. This is so trivial (just take the least significant bit of $x$) that $f(x)$ is efficiently computed directly, and therefore a proof is unnecessary, $g(x,p_x)=f(x)$.
+Composite numbers: $f(x)$ answers the question 'is the decimal representation of $x$ a composite number?'. One possible proof in the yes direction (you only have to prove that direction) is to give a pair of factors. e.g. $x=72$, $p_x=(8,9)$. Then $g(x,p)$ simply involves multiplying together the factors and checking they are equal to $x$.
+Graph isomorphism: Given two graphs $G_1$ and $G_2$ (here $x$ contains the description of both graphs), $f(x)$ answers the question 'are the two graphs isomorphic?'. The proof $p_x$ is a permutation: a statement of how the vertices in $G_1$ map to those of $G_2$. The function $g(x,p_x)$ verifies that $p_x$ is a valid permutation, permutes the vertices of $G_1$ using the specified permutation, and verifies that the adjacency matrix is the same as that of $G_2$.
+Minesweeper: The old favourite game built into windows (and others) can be expressed like this. Imagine a minesweeper board that is partially uncovered, so some cells are unknown, and some cells have been uncovered to reveal how many mines are in the neighbouring cells. This is all built into the variable $x$. $f(x)$ asks the question 'is there a valid assignment of mines on the uncovered region?'. The proof, $p_x$ is simply one such assignment of mines. This is easily verified using $g(x,p_x)$ which simply ensures consistency with every known constraint.
+
All of these problems are in $\text{NP}$ because they fit the definition of an efficiently verifiable solution. Some of them are known to be in $\text{P}$ as well: we've already stated that odd testing is in $\text{P}$. Composite numbers also is, because it is efficient to check if a number is prime using AKS primality testing.
+ +Graph isomorphism and minesweeper are not known to be in $\text{P}$. Indeed, minesweeper is known to be $\text{NP}$-complete, i.e. if it can be solved efficiently, every problem in $\text{NP}$ is in $\text{P}$. Many people suspect that $\text{P}\neq\text{NP}$, and hence Minesweeper would have instances which take longer than polynomial time to solve.
+ +One possible way to solve an $\text{NP}$ problem is, for a fixed $x$, simply to test all possible proofs $p_x$ up to a maximum length $m=\text{poly}(n)$, and see if there's a satisfying solution, i.e. to search for a solution $g(x,p_x)=1$. Obviously, that takes time $O(2^m\text{poly}(m))$, as there are exponentially many items to search, each requiring a polynomial time to compute. This can be improved by implementing Grover's search: we just search for a solution $g(x,p_x)=1$ (i.e. the valid $p_x$ becomes the marked item), and this takes a time $O(2^{m/2}\text{poly}(m))$. This is massively faster, but does not change the assessment of whether the running time is polynomial or something worse; it has not become a polynomial time algorithm. For example, graph isomorphism would have to search over all possible permutations. Minesweeper would have to search over all possible assignments of mines on uncovered squares.
+ +Of course, some of the time, additional structure in the problem permits different solutions that do not require the searching of all possible proofs. There, Grover's search is of less, or even no, use to us, but it might be that we can come up with a polynomial time algorithm in another way. For example, the case of composite testing: classically, finding the factors of a number appears to be hard: we can't do much better than testing all possible factors, so making use of that form of proof doesn't help much, but, as already mentioned, the question can be resolved efficiently via another route, AKS primality testing.
+",1837,,1837,,5/30/2018 8:14,5/30/2018 8:14,,,,3,,,,CC BY-SA 4.0 +2186,2,,2155,5/29/2018 19:12,,5,,"You get two decompositions for your matrix (let's call it $A$) because you are using two different operatorial bases.
+ +In the first case you are considering the matrix as acting in a space of dimension $3\times 2$, that is, using the operatorial basis $\{\lambda_i\sigma_j\}_{ij}\equiv\{\lambda_i\otimes\sigma_j\}_{ij}$.
+ +In other words, you are computing the coefficients $c_{ij}=\operatorname{tr}((\lambda_i\otimes \sigma_j) A)$, +finding $c_{61}$ to be the only not vanishing term. +This decomposition will be unique, because +$\operatorname{tr}\big[ (\lambda_i\sigma_j)(\lambda_k\sigma_l) \big]=N_{ij} \delta_{ik}\delta_{jl}$.
+ +On the other hand, the second decomposition is obtained thinking of $A$ as a matrix in a space of dimensions $2\times 3$, that is, by decomposing it using the operatorial basis $\{\sigma_i\lambda_j\}_{ij}\equiv\{\sigma_i\otimes\lambda_j\}_{ij}$. +This gives you new coefficients +$d_{ij}\equiv\operatorname{tr}((\sigma_i \otimes\lambda_j) A)$, which do not have to be (and indeed are not) the same as the $c_{ij}$.
+ +There is no paradox because $\{\sigma_i\otimes\lambda_j\}_{ij}$ and $\{\lambda_i\otimes\sigma_j\}_{ij}$ are two entirely different operatorial bases for a space of dimension $6$.
+",55,,55,,08-09-2018 08:51,08-09-2018 08:51,,,,1,,,,CC BY-SA 4.0 +2187,2,,2166,5/29/2018 22:08,,2,,"Complexity classes are generally defined with regard to the size of the input. The relevant sizes here are $n$ (the number of qubits on which you let Grover's algorithm operate) and a number you haven't mentioned yet, call it $m$, of bits needed to describe the subroutine generally referred to as the oracle. Typically, the oracle will be efficiently implemented in a way that scales polynomially in $n$, which is the case, for example, if you encode a typical boolean satisfiability problem in the oracle.
+ +In any case, you do not get a gain in complexity class using Grover's algorithm: It takes exponentially many quantum operations, typically $m*2^{n/2}$, to solve a problem we could brute-force in exponentially many steps, typically $m*2^{n-1}$, on a classical computer anyways. This means that problems known (e.g. EXPTIME) or suspected (e.g. NP) to take exponential runtime will still require exponential runtime.
+ +However, physicists like to appeal to the notion that this is still an exponential speed-up with no known (or indeed readily conceivable) classical equivalent. This is most apparent in the database example where the oracle function is a database lookup and Grover's algorithm can cause one to need many fewer lookups than there are data in the database. In this sense, there is still a significant advantage, although it is completely lost in the complexity class picture.
+",,user1039,,,,5/29/2018 22:08,,,,2,,,,CC BY-SA 4.0 +2188,1,2189,,5/30/2018 10:03,,6,112,"I was working on the Grover's algorithm and the most common example is for a unitary distribution in a quantum database, for example:
+ +$|\psi\rangle = \frac{1}{2}|00\rangle + \frac{1}{2}|01\rangle + \frac{1}{2}|10\rangle + \frac{1}{2}|11\rangle.$
+ +Is there a way to obtain arbitrary distribution (the above one is achieved by applying $H^{\otimes n}$ gates), e.g.
+ +$|\psi\rangle = \frac{1}{3}|00\rangle + \frac{1}{4}|01\rangle + \sqrt{\frac{83}{144}}|10\rangle + \frac{1}{2}|11\rangle$ +? Does the structure of Grover's algorithm differ in such a case?
+",2098,,,,,5/30/2018 10:52,How to obtain arbitrary distribution in quantum database,According to this paper,
+ +++ +A significant conclusion from this solution is that generically the generalized algorithm also has $O(\sqrt{N/r})$ running time
+
Where 'r' is the number of marked states. By generalized, the authors meant a distribution with arbitrary complex amplitudes. So it seems to answer your question. That the modified initialization would still perform in the same way as the original one.
+",2403,,,,,5/30/2018 10:52,,,,0,,,,CC BY-SA 4.0 +2190,1,2191,,5/30/2018 14:58,,9,1581,"I trying to do some tests in the IBM Q5 computer of IBM quantm experience for some simple error correction protocols, but as I can see, some operations between the qubits are not allowed.
+ +For example, it is not possible to perform a CNOT operation with the fourth qubit or when selecting one for as the target qubit for the operation, it does not allow to use any of the other qubits as control qubits.
+ +I have been thinking about the fact that maybe it is because of the physical implementation of such computer, but as I do not know much about the construction of quantum computers I do not know if that might be the cause. So I am wondering if that is actually the issue, or otherwise why those operations are not allowed.
+",2371,,26,,12/14/2018 5:40,12/14/2018 5:40,Allowed CNOT gates for IBM Q 5 quantum computer,Yes, the physical implementation is the constraint. If you look at the image of the processor you'll notice the connections between qubits. This gives you an idea of how you can perform two qubit gates between particular qubits.
+ +Here's the documentation on the Tenerife backend. In the section titled Two Qubit gates at the bottom you can read the details. Also the directions of the gates are also detailed in a log file there.
+ +https://github.com/QISKit/qiskit-backend-information/tree/master/backends/tenerife/V1
+ +I am thinking about the following question:
+ +++ +Assuming that we have some given state $\rho$ and we perform a + measurement with $k$ outcomes on this state. Then we can describe the + measurement in outcomes as eigenvalues of the measurable, i.e., the + Hermitian operator that I denote by $D$, with probabilities + $\mathrm{Tr}[D_i\rho]$, where $D_i$ are the projectors in the $i^{th}$ + eigenspace of $D$, i.e. for the eigendecomposition $D = \sum_i + \lambda_i s_i s_i^T = \sum_i \lambda_i D_i$.
+
I was wondering if my assumption is true. If the number of (distinguishable?) outcomes for any Hermitian operator is given by $k$ i.e. then we have only $k$ non-zero eigenvalues and hence $D$ must be of rank $\leq k$?
+",2054,,55,,10/28/2022 6:07,10/28/2022 6:07,How is the number of measurement outcomes linked to the rank of the observable?,You are implicitly making a specific assumption here: that the $\{D_i\}$ are rank 1 projectors.
+ +If your $\{D_i\}$ are rank-1 projectors, i.e. taking the form $D_i=s_is_i^T$, then because there is a completeness relation for measurement operators, +$$ +\sum_iD_i=\mathbb{I}, +$$ +then you must have a number of outcomes equal to the dimension of the Hilbert space you're measuring. Call that $k$. Now, if you define $D=\sum_i\lambda_iD_i$ where the $\lambda_i$ are distinct, then $D$ must have rank either $k$ or $k-1$: if one of the $\lambda_i$ is 0, then the number of non-zero values (which is equivalent to the rank) is $k-1$.
+ +Now, strictly, the $D_i$ could be projectors, but not have rank 1 (in fact, they don't even have to be projectors, but we won't go there...), but instead a rank $r_i=\text{Tr}(D_i)$. In this case, either $D$ is full rank (which we'll still call $k$) or, if a particular $\lambda_j=0$, then it has rank $k-r_j$, because that's the number of non-zero eigenvalues $D$ has. Here, the number of distinguishable outcomes is potentially much smaller than the rank of $D$. All you really know is that $\text{rk}(D)\geq |\{D_i\}|-1$ (i.e. the number of measurement operators minus 1, in case one of the eigenvalues is 0). But that could be a very loose bound in some circumstances (and the bound is the opposite way round to what you were asking).
+ +Overall, the answer is that the number of distinguishable measurement outcomes is not equal to the rank of the measurement operator.
+",1837,,,,,5/30/2018 15:46,,,,0,,,,CC BY-SA 4.0 +2194,2,,2190,5/30/2018 16:55,,6,,"The five qubit IBM devices have a ‘bow tie’ architecture, which mean that it is only possible to interact certain pairs of qubits. These are shown in the answer of Andrew O.
+ +The interaction that can be performed between these pairs of qubits is a CNOT with a particular direction. However, it is possible to implement others indirectly.
+ +For example, to perform a CNOT with q0 as control and q1 as target, use
+ +h q[0];
+h q[1];
+cx q[1], q[0];
+h q[1];
+h q[0];
+The above can be added in the QASM editor. Or you could do the same with the GUI: it is a CNOT with Hadamads before and after on both qubits. The Hadamards effectively reverse the CNOT direction.
+",409,,,,,5/30/2018 16:55,,,,4,,,,CC BY-SA 4.0 +2195,1,,,5/31/2018 2:58,,8,1992,"I have followed the installation steps, regarding QISKit working environment. For circuit visualization, I've installed latex as in addition to poppler to convert from PDF to images. Afterwards, I followed the example given here.
+ +I wrote the code and after running, the program run but I didn't get the circuit visualization. I don't know what is the problem, even I have not received any error messages.
+ +So any ideas?
+",2519,,26,,03-12-2019 09:29,03-12-2019 09:29,Visualization of Quantum Circuits when using IBM QISKit,I am currently going through Nielsen's QC bible and having still some foundational / conceptual problems with the matter.
+ +I have tried to retrieve this $8 {\times} 8$ matrix describing the QFT of 3 qubits via Kronecker product in various attempts.
+ +Hadamard transform can be decomposed into $H \otimes 1 \otimes 1$, and the others are fundamentally kronecker products of the 4x4 matrices of S resp. T with the 2x2 identity.
+ +Whats wrong with my approach?
+ +EDIT:
+ +$T\text{=}\left( +\begin{array}{cccccccc} + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & e^{\frac{\pi i}{4}} & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & e^{\frac{\pi i}{4}} \\ +\end{array} +\right)$
+ +which is derived from $R_k = \left( +\begin{array}{cc} + 1 & 0 \\ + 0 & e^{2 i \pi /2^k} \\ +\end{array} +\right)$, being $S$ for $k=1$ and $T$ for $k=2$.
+ +EDIT 2:
+ +The controlled T-operation can be represented in computational basis as
+ +$\left( +\begin{array}{cccc} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & e^{2 \pi i / 2^k } \\ +\end{array} +\right)$.
+ +EDIT 3:
+ +In mathematica, one faulty calculation of mine is:
+ +$\text{SWAP}\text{=}\left( +\begin{array}{cccccccc} + 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ +\end{array} +\right)$
+ +SWAP*KroneckerProduct[IdentityMatrix[2], IdentityMatrix[2], H]KroneckerProduct[IdentityMatrix[2], S] + KroneckerProduct[ IdentityMatrix[2], H, IdentityMatrix[2]] * T KroneckerProduct[S, IdentityMatrix[2]] + KroneckerProduct[H, IdentityMatrix[2], + IdentityMatrix[2]] // MatrixForm
+ +which gives:
+ +$\left( +\begin{array}{cccccccc} + \frac{1}{2 \sqrt{2}} & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & -\frac{1}{2 \sqrt{2}} & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & \frac{e^{\frac{i \pi }{2}}}{2 \sqrt{2}} & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ + 0 & 0 & 0 & 0 & 0 & 0 & 0 & -\frac{e^{\frac{i \pi }{2}} i^2}{2 \sqrt{2}} \\ +\end{array} +\right)$
+",2522,,2522,,5/31/2018 15:22,5/31/2018 15:39,Example of Quantum Fourier Computation for three qubits,The tensor products for the individual gates are all being calculated correctly, and the matrices are being multiplied in the correct order. In this case, it turns out that it is a Mathematica programming error, using the * operator for element-by-element multiplication of matrices rather than matrix multiplication. The first clue was that the overall output was not even unitary, even though the individual gates seemed to be correct.
+",1837,,,,,5/31/2018 15:39,,,,0,,,,CC BY-SA 4.0 +2198,1,2204,,5/31/2018 16:18,,9,179,"I'm relatively new to quantum computing and my goal is to learn how to implement algorithms that I read in papers. While I have found many circuit snippets I have yet to find a repository of examples on GitHub or other places where I would go to find machine learning code. Does an analogous quantum computing repository exist?
+",418,,,,,06-11-2018 07:59,Where can I find example circuits to learn from?,First let me mention a minor point concerning terminology. The type of channel you are suggesting is often called a Pauli channel; the term depolarizing channel usually refers to the case where $p_x = p_y = p_z$.
+ +Anyway, it is not really correct to say that Pauli channels are the channel model considered for quantum error correction. Standard quantum error correcting codes can protect against arbitrary errors (represented by any quantum channel you might choose) so long as the errors do not affect too many qubits.
+ +As an example, let us consider an arbitrary single-qubit error, represented by a channel $\Phi$ mapping one qubit to one qubit. Such a channel can be expressed in Kraus form as +$$ +\Phi(\rho) = A_1 \rho A_1^{\dagger} + \cdots + A_m \rho A_m^{\dagger} +$$ +for some choice of Kraus operators $A_1,\ldots,A_m$. (For a qubit channel we can always take $m = 4$ if we want.) You could, for instance, choose these operators so that $\Phi(\rho) = |0\rangle \langle 0|$ for every qubit state $\rho$, you could make the error unitary, or whatever else you choose. The choice can even be adversarial, selected after you know how the code works.
+ +Each of the Kraus operators $A_k$ can be expressed as a linear combination of Pauli operators, because the Pauli operators form a basis for the space of 2 by 2 complex matrices: +$$ +A_k = a_k I + b_k X + c_k Y + d_k Z. +$$ +If you now expand out the Kraus representation of $\Phi$ above, you will obtain a messy expression where $\Phi(\rho)$ looks like a linear combination of operators of the form $P_i \rho P_j$ where $i,j\in\{1,2,3,4\}$ and $P_1 = I$, $P_2 = X$, $P_3 = Y$, and $P_4 = Z$.
+ +Now imagine that you have a quantum error correcting code that protects against an $X$, $Y$, or $Z$ error on one qubit. The usual way this works is that some extra qubits in the 0 state are tacked on to the encoded data and a unitary operation is performed that reversibly computes into these extra qubits a syndrome describing which error occurred, if any, and which qubit was affected.
+ +Supposing that the arbitrary error $\Phi$ happened on the first qubit for simplicity, after the syndrome computation you will end up with a state that looks like a linear combination of terms like this: +$$ +P_i |\psi\rangle \langle \psi| P_j \otimes |P_i\: \text{syndrome}\rangle\langle P_j\:\text{syndrome}|. +$$ +The assumption here is that $|\psi\rangle$ represents the encoded data without any noise, $P_i$ and $P_j$ act on the first qubit, and that ""$P_i$ syndrome"" and ""$P_j$ syndrome"" refer to the standard basis states that indicate that these errors have occurred on the first qubit. (The situation is similar for the error affecting any other qubit; I'm just trying to keep the notation simple by assuming the error happened to the first qubit.)
+ +Now the key is that you measure the syndrome to see what error occurred, and all of the cross terms disappear because of the measurement. You are left with a probabilistic mixture of states that look like +$$ +P_i |\psi\rangle \langle \psi| P_i \otimes |P_i\: \text{syndrome}\rangle\langle P_i\:\text{syndrome}|. +$$ +The error is corrected and the original state is recovered. In effect, by measuring the syndrome, you ""project"" or ""collapse"" the error to something that looks like a Pauli channel.
+ +This is all described (somewhat briefly) in Section 10.2 of Nielsen and Chuang.
+",1764,,,,,5/31/2018 16:33,,,,4,,,,CC BY-SA 4.0 +2200,1,,,5/31/2018 22:35,,11,2047,"I am trying to get used to IBM Q by implementing three qubits Grover's algorithm but having difficulty to implement the oracle.
+ +Could you show how to do that or suggest some good resources to get used to IBM Q circuit programming?
+ +What I want to do is to mark one arbitrary state by flipping its sign as the oracle supposed to do.
+ +For example, I have
+ +$1/\sqrt8(|000\rangle+|001\rangle+|010\rangle+|011\rangle+|100\rangle+|101\rangle+|110\rangle+|111\rangle)$.
+ +and I want to mark $|111\rangle$ by flipping its sign to $-|111\rangle$. I somehow understand that CCZ gate would solve the problem but we do not have CCZ gate in IBM Q. The combination of some gates will act the same as CCZ but I am not sure how to do that yet. And I am also struggling for the other cases not only for $|111\rangle$.
+ +Two qubits case is simple enough for me to implement, but three qubits care is still confusing to me.
+",2100,,55,,06-03-2018 16:27,06-09-2021 05:39,Implementation of the oracle of Grover's algorithm on IBM Q using three qubits,In the paper A quantum-implementable neural network model (Chen, Wang & Charbon, 2017), on page 18 they mention that ""There are 784 qurons in the input layer, where each quron is comprised of ten qubits.""
+ +That seems like a misprint to me. After reading the first few pages I was under the impression that they were trying to use $10$ qubits to replicate the $784$ classical neurons in the input layer. Since $2^{10}=1024>784$, such that each sub-state's coefficient's square is proportional to the activity of a neuron. Say the square of the coefficient of $|0000000010\rangle$ could be proportional to the activation of the $2$-nd classical neuron (considering all the $784$ neurons were labelled fom $0$ to $783$).
+ +But if what they wrote is true: ""There are 784 qurons in the input layer"" it would mean there are $7840$ qubits in the input layer, then I'm not sure how they managed to implement their model experimentally. As of now we can properly simulate only ~$50$ qubits.
+ +However, they managed to give an error rate for $>7840$ qubits (see Page 21: ""Proposed two-layer QPNN, ten hidden qurons, five select qurons - 2.38""). No idea how's they managed to get that value. Could someone please explain?
+",26,,26,,12/23/2018 12:28,12/23/2018 12:28,How did the authors manage to simulate and get the error estimate for a neural network with greater than 7840 qubits?,++ +As of now we can properly simulate only ~50 qubits.
+
You are talking about a full quantum simulation of a vector containing $2^{50}$ elements.
+ +In quantum neural networks and quantum annealing, we usually only need something close to the ground state (optimal value) rather than the absolute global minimum.
+ +Here is another example from 2017 where 1000 qubits are simulated:
+ +Here's an example from 2015 where 1000 qubits are simulated (it says bits rather than qubits, but they are the qubits of the D-Wave device):
+ +Recently I found out the Applications of Quantum Computing Professional Certificate Program that MITxPRO is offering for people interested in quantum computing. I saw that it is consisted of four courses that can be done independently or as a whole program. This is the link for the course.
+ +I am especially interested in just the last one of such four courses, but I do not know if it would be necessary to take the other ones so that I could do such course.
+ +That's why I was wondering if someone here has started this course, and so if there is someone, if he could give an insight about which is the level required for taking such courses, the time required in order to complete the homework and his opinion about the course in general. Also it would be interesting to hear if you think that taking all courses should be necessary (although I am aware of the fact that just one of the courses has been given, so this would be a subjective opininon).
+",2371,,26,,12/13/2018 19:51,01-03-2020 04:07,Reference on MITxPRO Applications of Quantum Computing Professional Certificate Program,I know this is not what you are asking but this paper: +Quantum Algorithm Implementations for Beginners explains the implementation of some machine learning algorithms. Hope this helps!
+",2100,,,,,06-01-2018 14:10,,,,1,,,,CC BY-SA 4.0 +2205,2,,2200,06-01-2018 15:27,,4,,"I am answering my question. After some google search, I found this image showing CCZ gate by CNOT, T dagger, and T gate. I tried this on IBM Q and it worked. I want to explore why it works but that's another story.
+ +For someone who is interested, here is my quantum circuit of Grover's algorithm finding |111> with one iteration.
+ +I signed up for this series because I was interested in the 2nd and 3rd courses.
+ +There are a lot of students from different backgrounds so I think that limits the depth of what the instructors can cover. The introductory course was too easy in terms of content, however useful in the form of industry perspectives and getting to know 'who is doing what' in hardware. My fear is that the remaining courses will be a bit too simple/general.
+ +The bulk of the time is spent watching videos. I set the speed to 1.25x or else it's just a bit too slow for me. You could complete the entire course in a weekend.
+ +Taking all the courses is absolutely not necessary but you do get a nice certificate at the end.
+ +Oct 31, 2018 Update
+ +I've finished all 4 courses and have to say the 2nd, 3rd, and 4th courses were great. They went into a reasonable amount of depth in the topics. I'd recommend the series to anyone starting out. If you're already familiar with the basics then maybe skip the first course.
+ +Jan 2, 2020 Update
+ +Since I received a few upvotes on this answer recently, I thought I would add a bit more information. The 4 course certificate program has since been split into two two-course programs. Quantum Computing Fundamentals and Quantum Computing Realities. My comments above still stand. Skip the fundamentals course if you're already familiar with the basics.
+",54,,54,,01-02-2020 17:39,01-02-2020 17:39,,,,0,,,,CC BY-SA 4.0 +2207,1,2208,,06-01-2018 17:06,,4,192,"I am going through Nielsen and Chuang and am finding the chapter on error-correction particularly confusing. At the moment I am stuck on exercise 10.12 which states
+ +Show that the fidelity between the state $|0 \rangle$ and $\varepsilon(|0\rangle\langle0|)$ is $\sqrt{1-2p\backslash3}$, and use this to argue that the minimum fidelity for the depolarizing channel is $\sqrt{1-2p\backslash3}$.
+ +As I understand $\varepsilon$ is a quantum operation and could be whatever we want as long as it fits the definition, do I assume $\varepsilon$ is the depolarizing channel or is there some general operation I don't know about.
+ +Thanks!
+",2528,,55,,7/26/2020 18:11,7/26/2020 18:11,How to find the fidelity between two state when one is an operator?,The channel $\mathcal{E}$ is explicitly defined in the preceding paragraph as being the depolarising channel. Thus, all you need to calculate is +$$ +F=\sqrt{\langle 0|\mathcal{E}(|0\rangle\langle 0|)|0\rangle}. +$$
+",1837,,,,,06-01-2018 17:45,,,,0,,,,CC BY-SA 4.0 +2209,1,2214,,06-01-2018 20:25,,7,494,"I am interested in a quantum algorithm that has the following characteristics:
+ +-
+
- output = 2n bits OR 2 sets of n bits (e.g. 2 x 3 bits) +
- the number of 1-bits in the first set of n-bits must be equal to the number of 1-bits in the second set. E.g. correct output =
0,0,0, 0,0,0(both 3-bit sets have zero 1-bits);1,0,0, 0,1,0(both 3-bit sets have one 1-bit);1,1,0, 0,1,1(both 3-bit sets have two 1-bit)
+ - Each time the quantum algorithm runs it must randomly return one of the possible solutions. +
Any idea how I can best implement such an algorithm on a quantum computer ?
+ +FYI I have tried the following algorithm (where n = 2 ) but it missed the 2 answers 0110 and 1001:
+
I work on a Quantum Information Science II: Quantum states, noise and error correction MOOC by Prof. Aram Harrow, and I do not understand which property of tensor products is used in one of the transitions in the videos.
+ +Let's consider an isometry $V: A \to B \otimes E$ ($E$ is a subspace to be thrown away at the end).
+ +Let's fix and orthonormal basis $\{ |e\rangle \}$ in $E$ and partially expand the isometry $V$ as $V = \sum_e V_e \otimes |e\rangle$, where each $V_e$ is a linear operator from $A$ to $B$.
+ +The Stinespring form of a quantum operation is a partial trace applied after an isometry: $N(\rho) = \mathrm{tr}_E [V \rho V^\dagger]$.
+ +Now, if we expand that with our representation of $V$, we get +$$ +N(\rho) = \mathrm{tr}_E \left[ +\sum_{e_1} \sum_{e_2} +\left( V_{e_1} \otimes |e_1\rangle \right) +\rho +\left( V_{e_2}^\dagger \otimes \langle e_2| \right) +\right]. +$$
+ +My question is how to get from here to the next step +$$ +N(\rho) = \mathrm{tr}_E \left[ +\sum_{e_1} \sum_{e_2} +(V_{e_1} \rho V_{e_2}^\dagger) \otimes |e_1 \rangle \langle e_2| +\right]? +$$
+ +(BTW, eventually, we end up with the Kraus operator decomposition of a channel: $N(\rho) = \sum_e V_e \rho V_e^\dagger$.)
+",528,,55,,2/19/2021 18:33,2/19/2021 18:33,Tensor product properties used to obtain Kraus operator decomposition of a channel,I am confused about how to understand the $Z$ gate in a Bloch sphere.
+ +Considering the matrix $Z = \begin{pmatrix} +1 & 0 \\ +0 & -1 +\end{pmatrix}$ it is understandable that $Z|0\rangle = |0\rangle$ and $Z|1\rangle = -|1\rangle$.
+ +It is explained here that $Z$ gate is $\pi$ rotation around the $Z$ axis. Then, how should I understand $Z|1\rangle = -|1\rangle$? Since $|1\rangle$ is the south pole, I feel it is natural to think that $\pi$ rotation around the $Z$ axis does not do anything.
+",2100,,26,,06-02-2018 17:56,06-03-2018 06:03,How to think about the Z gate in a Bloch sphere?,Puzzle
+ +I have the following puzzle for which I would like to create a quantum algorithm.
+ +-
+
- There are 2 players that need to complete 3 tasks as fast as possible. +
- There are 3 different types of tasks (
A, B, C)
+ - There are 3 different types of tools (
a, b, c)
+ - Each player will only get 2 tools (they might get the same tool twice) +
- Tool a will make that the player can finish task
A10 minutes faster than without toola.
+ - Tool
bwill make that the player can finish taskB10 minutes faster than without toolb.
+ - Tool
cwill make that the player can finish taskC10 minutes faster than without toolc.
+ - The output of the quantum algorithm must be (a) a random combination of the 3 tasks (the same task might appear multiple times) and (b) a random assignment of 2 tools to each of the 2 players but it should also remain a fair competition (in other words one player will not gain more time in total thanks to the set of tools he got). +
So a possible outcome of the quantum algorithm:
+ +-
+
- Tasks
A, A, C(note that same task can appear multiple times) and
+ - Player one gets tools
a,b
+ - Player two gets tools
a,a(although he gets 2atools - he can only use one tool at a time - so the 2ndatool would not give any benefits)
+
So, in this case, both players will equally benefit (= 20 minutes) thanks to tool a and the 2 tasks A, A.
So how would you implement such a problem in a quantum algorithm?
+ ++ +
Generalized Puzzle
+ +Of course this puzzle can be further generalized as:
+ +-
+
- each player has to complete
ntasks (and not 3)
+ - instead of 3 different types of tasks (
A, B, C) and 3 corresponding different types of tools (a, b, c), there aretdifferent types of tasks with corresponding tools giving them a 10 minute performance benefit.
+ - each player gets
ktools instead of 2.
+
I don't need an answer on this generalized puzzle ! I am more than happy to get an answer on the simple puzzle.
+",2529,,2529,,06-04-2018 07:31,06-04-2018 07:31,Algorithm to allocate tasks and tools fairly to 2 players,The way to think about the Bloch sphere is in terms of the density matrix for the state. $Z$ acting on either $|0\rangle\langle 0|$ or $|1\rangle\langle 1|$ does nothing, as is true for any diagonal density matrix. To see the effect of the rotation, you need to look at how any non-diagonal density matrix is changed by $Z$, such as $|+\rangle\langle +|$.
+",1837,,,,,06-01-2018 22:31,,,,0,,,,CC BY-SA 4.0 +2214,2,,2209,06-01-2018 22:49,,2,,"There are probably better ways than this, but here’s one you could try:
+ +Start as you have done, with Hadamards on every qubit of the first register, then controlled nots between matching pairs of qubits across the two registers. This creates a uniform superposition of terms $|x\rangle|x\rangle$.
+ +Now you need to somehow perform a random permutation on the second register. Introduce $\binom{n}2$ ancillary qubits. Apply Hadamard on each, and use each qubit to control the application of a swap between a different pair of qubits on the second register. Then forget about the ancillary qubits, and just measure the first two registers. (I’m guessing this gives you a sufficiently random permutation.)
+",1837,,1837,,06-02-2018 09:52,06-02-2018 09:52,,,,4,,,,CC BY-SA 4.0 +2215,2,,2211,06-01-2018 22:52,,2,,"As per Wikipedia, we can write any pure state as $$|\psi\rangle = \cos\left( \frac{\theta}{2} \right) |0 \rangle + e^{i \phi} \sin\left( \frac{\theta}{2} \right) |1 \rangle$$
+ +Where $\theta$ and $\phi$ are the angles on the Bloch sphere:
+ +Almost any point on the surface (i.e. pure state) has a unique representation in terms of the angles, except for the poles. Just like on the Earth the South Pole has no well-defined longitude (any longitude works the same), for the $|1 \rangle$ state any phase $\phi$ means the same thing. The “latitude” $\theta$ is here $\pi$, let's plug that into the equation:
+ +$$|1\rangle = \cos\left( \frac{\pi}{2} \right) |0 \rangle + e^{i \phi} \sin\left( \frac{\pi}{2} \right) |1 \rangle = $$ +$$ = 0 + e^{i \phi} |1 \rangle$$
+ +If you are familiar with Euler's identity, you will probably recognise $e^{i \phi}$ as a rotation in the complex plane. In particular, since $Z$ is a rotation for $\phi = \pi$, we get the famous $e^{i \pi} = -1$, finally arriving at $|1 \rangle = - |1 \rangle$.
+",580,,,,,06-01-2018 22:52,,,,3,,,,CC BY-SA 4.0 +2217,2,,2211,06-02-2018 01:03,,11,,"$|1\rangle$ and $-|1\rangle$ are assigned to the same point on the Bloch sphere because they are equal up to global phase. Algebraically: $|1\rangle \equiv -|1\rangle$ where $\equiv$ means ""equal up to global phase"". Meaning there is some $\theta$ such that $-|1\rangle = e^{i \theta} |1\rangle$.
+ +The thing that is confusing you is that, despite the fact that $|0\rangle \equiv Z |0\rangle$ and $|1\rangle \equiv Z |1\rangle$, this is not true for linear combinations of the two. For example, $Z |+\rangle \not\equiv Z |+\rangle$ even though $|+\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle$.
+",119,,119,,06-03-2018 06:03,06-03-2018 06:03,,,,0,,,,CC BY-SA 4.0 +2219,2,,2166,06-02-2018 06:07,,7,,"Summary
+ +-
+
- There is a theory of complexity of search problems (also known as relation problems). This theory includes classes called FP, FNP, and FBQP which are effectively about solving search problems with different sorts of resources. +
- From search problems, you can also define decision problems, which allows you to relate search problems to the usual classes P, NP, and BQP. +
- Whether you consider the search version of the decision version of the problem, the way that you consider the input to the Unstructured Search problem will determine what upper bounds you can put on its complexity. +
The complexity of relation problems
+ +As you note, Grover's problem solves a search problem, which in the complexity literature is sometimes also known as a relation problem. That is, it is a problem of the following sort:
+ +++ +The structure of a general search problem.
+
Given an input $x$ and a binary relation $R$, find a $y$ such that $R(x,y)$ holds.
The complexity classes FP and FNP are defined in terms of such problems, where in particular one is interested in the case where $y$ has length at most a polynomial function of the length of $x$, and where the relation $R(x,y)$ can itself be computed in an amount of time bounded by some polynomial in the length of $(x,y)$.
+ +In particular: the example of the 'database search' problem for which Grover's Search is usually applied can be described as follows.
+ +++ +Unstructured Search.
+
+ Given an input oracle $\mathcal O: \mathcal H_2^{\otimes m+1} \!\to \mathcal H_2^{\otimes m+1}$ such that $\mathcal O \lvert a \rangle \lvert b \rangle = \lvert a \rangle \lvert b \oplus f(a) \rangle$ for some function $f: \{0,1\}^m \to \{0,1\}$, find a $y$ such that $\mathcal O + \lvert y \rangle \lvert 0 \rangle = \lvert y \rangle \lvert 1 + \rangle$.
Here, the oracle itself is the input to the problem: it plays the role of $x$, and the relation which we are computing is +$$ R(\mathcal O,y) \;\;\equiv\;\; \Bigl[\mathcal O + \lvert y \rangle \lvert 0 \rangle = \lvert y \rangle \lvert 1 + \rangle\Bigr] \;\;\equiv\;\; \Bigl[ f(y) = 1 \Bigr].$$
+ +Suppose that, instead of an oracle, we are provided with a specific input $x$ which describes how the function $f$ is to be computed, we can then consider which complexity class this problem belongs to. As pyramids indicates, the appropriate complexity class we obtain depends on how the input is provided.
-
+
Suppose that the input function is provided as an database (as the problem is sometimes described), where each entry to the database has some length $\ell$. If $n$ is the length of the string $x$ used to describe the entire database, then the database has $N = n\big/\ell$ entries. It is then possible to exhaustively search the entire database by querying each of the $N$ entries in sequence, and stop if we find an entry $y$ such that $f(y) = 1$. Supposing that each query to the database takes something like $O(\log N) \subseteq O(\log n)$ time, this procedure halts in time $O(N \log N) \subseteq O(n \log n)$, so that the problem is in FP.
+ +Assuming that the database-lookup can be done in coherent superposition, Grover's algorithm allows this problem is in FBQP. However, as FP ⊆ FBQP, the classical exhaustive search also proves that this problem is in FBQP. All that we obtain (up to log factors) is a quadratic speed-up due to a savings in the number of database queries.
+Suppose that the input function is described succinctly, by a polynomial-time algorithm that takes a specification $x \in \{0,1\}^n$ and an argument $y \in \{0,1\}^m$ and computes $\mathcal O : \mathcal H_2^{m+1} \!\to \mathcal H_2^{m+1}\!$ on a standard basis state $\lvert y \rangle\lvert b \rangle$, where $m$ may be much larger than $\Omega(\log n)$. An example would be where $x$ specifies the CNF form of some boolean function $f: \{0,1\}^m \to \{0,1\}$ for $m \in O(n)$, in which case we may efficiently evaluate $f(y)$ on an input $y \in \{0,1\}^m$ and thereby efficiently evaluate $\mathcal O$ on standard basis states. This puts the problem in FNP.
+ +Given a procedure to evaluate $f(y)$ from $(x,y)$ in time $O(p(n))$ for $n = \lvert x \rvert$, Grover's algorithm solves the problem of Unstructured Search for $\mathcal O$ in time $O(p(n) \sqrt{2^m})$ $\subseteq O(p(n) \sqrt{2^n})$. This is not polynomial in $n$, and so does not suffice to put this problem in FBQP: we only obtain a quadratic speedup — though this is still a potentially huge savings of computation time, assuming that the advantage provided by Grover's algorithm is not lost to the overhead required for fault-tolerant quantum computation.
+
In both cases, the complexity is determined in terms of the length $n$ of the string $x$ *which specifies how to compute the oracle $\mathcal O$. In the case that $x$ represents a look-up table, we have $N = n\big/\ell$, in which case the performance as a function of $N$ is similar to the performance as a function of $n$; but in the case that $x$ succinctly specifies $\mathcal O$, and $N \in O(2^{n/2})$, the big-picture message that Grover's solves the problem in $O(\sqrt N)$ queries obscures the finer-grained message that this algorithm is still exponential-time for a quantum computer.
+ +Decision complexity from relation problems
+ +There is a straightforward way to get decision problems from relation problems, which is well-known from the theory of NP-complete problems: to turn the search problem to a question of the existence of a valid solution.
+ +++ +The decision version of a general search problem.
+
Given an input $x$ and an binary relation $R$, determine whether $\exists y: R(x,y)$ holds.
The complexity class NP can essentially be defined in terms of such problems, when the relationship $R$ is efficiently computable: the most famous NP-complete problems (CNF-SAT, HAMCYCLE, 3-COLOURING) are about the mere existence of a valid solution to an efficiently verifiable relationship problem. This switch from producing solutions to simply asserting the existence of solutions is also what allows us to describe versions of integer factorisation which are in BQP (by asking whether there exist non-trivial factors, rather than asking for the values of non-trivial factors).
+ +In the case of Unstructured Search, again which complexity class best describes the problem depends on how the input is structured. Determining whether there exists a solution to a relationship problem may be reduced to finding and verifying a solution to that problem. Thus in the case that the input is a string $x$ specifying the oracle as a look-up table, the problem of unstructured search is in P; and more generally if $x$ specifies an efficient means of evaluating the oracle, the problem is in NP. It is also possible that there is a way of determining whether there exists a solution to Unstructured Search which does so without actually finding a solution, though it is not clear in general how to do so in a way which would provide an advantage over actually finding a solution.
+ +Oracle complexity
+ +I have conspicuously been shifting from talking about the oracle $\mathcal O$, to ways that an input $x$ can be used to specify (and evaluate) the oracle $\mathcal O$. But of course, the main way in which we consider Grover's algorithm is as an oracle result in which evaluating the oracle takes a single time-step and requires no speficiation. How do we consider the complexity of the problem in this case?
+ +In this case, we are dealing with a relativised model of computation, in which evaluating this one specific oracle $\mathcal O$ (which, remember, is the input to the problem) is a primitive operation. This oracle is defined on all input sizes: to consider the problem for searching on strings of length $n$, you must specify that you are considering how the oracle $\mathcal O$ acts on inputs of length $n$, which again would be done by considering the length of a boolean string $x$ taken as input. In this case, the way in which we would present the problem might be as follows.
+ +++ +Unstructured Search relative to Oracle $\mathcal O$.
+ +
Given an input $x = 11\cdots 1$ of length $n$,+
+ +- +
find a $y \in \{0,1\}^n$ (relation problem) or
- +
determine whether there exists a $y \in \{0,1\}^n$ (decision problem)
such that $\mathcal O \lvert y \rangle \lvert 0 \rangle = \lvert y \rangle \lvert 1 \rangle$.
+
This problem is in $\mathsf{NP}^{\mathcal O}$ (for the decision problem) or $\mathsf{FNP}^{\mathcal O}$ (for the relation problem), depending on which version of the problem you wish to consider. Because Grover's algorithm is not a polynomial-time algorithm, this problem is not known to be in $\mathsf{BQP}^{\mathcal O}$ or $\mathsf{FBQP}^{\mathcal O}$. In fact, we can say something stronger, as we will soon see.
+ +The reason why I brushed over the actual, oracle-based description of Unstructured Search was in order to touch on your point of complexity, and in particular to touch on the question of input size. The complexity of problems are largely governed by how the inputs are specified: as a succinct specification (in the case of how a function is specified in CNF-SAT), as an explicit specification (in the case of a look-up table for a function), or even as an integer specified in unary, i.e. as the length of a string of 1s as above (as in ""Unstructured Search relative to Oracle $\mathcal O$"" above).
+ +As we can see from the latter case, if we treat the input only as an oracle, the situation looks a bit un-intuitive, and it certainly makes it impossible to talk about the ways that the ""database"" can be realised. But one virtue of considering the relativised version of the problem, with an actual oracle, is that we can prove things which otherwise we have no idea how to prove. If we could prove that the decision version of the succinct unstructured search problem was in BQP, then we would stand to realise an enormous breakthrough in practical computation; and if we could prove that the decision problem was not actually in BQP, then we would have shown that P ≠ PSPACE, which would be an enormous breakthrough in computational complexity. We don't know how to do either. But for the relativised problem, we can show that there are oracles $\mathcal O$ for which the decision version of ""Unstructured Search relative to $\mathcal O$"" is in $\mathsf{NP}^{\mathcal O}$ but not in $\mathsf{BQP}^{\mathcal O}$. This allows us to show that while quantum computing is potentially powerful, there are reasons to expect that BQP probably doesn't contain NP, and that the relation version of Unstructured Search in particular is unlikely to be contained in FBQP without imposing strong constraints on how the input is represented.
+",124,,,,,06-02-2018 06:07,,,,0,,,,CC BY-SA 4.0 +2221,2,,2210,06-02-2018 17:36,,3,,"As pointed out in a comment, what you wrote as $\rho$ should more precisely be written as $\rho\otimes\mathbb 1$ (although the Kraus operator decomposition can be obtained similarly with any initial ancilla state, in which case you have $\rho\otimes|\phi\rangle\!\langle\phi|$).
+ +The standard algebraic properties of tensor product spaces then tell you that +$$(A\otimes B)(C\otimes D)=(AC)\otimes(BD),$$ +from which you immediately get your result.
+",55,,528,,06-10-2018 21:14,06-10-2018 21:14,,,,2,,,,CC BY-SA 4.0 +2222,1,,,06-03-2018 12:42,,15,665,"I am interested in a quantum algorithm that gets as input an n-bit sequence and that produces as output a reshuffled (permuted) version of this n-bit sequence.
+ +E.g. if the input is 0,0,1,1 (so n=4 in this case) then the possible answers are:
+ +-
+
- 0,0,1,1 +
- 0,1,0,1 +
- 0,1,1,0 +
- 1,0,0,1 +
- 1,0,1,0 +
- 1,1,0,0 +
Note that only one output should be generated which is randomly chosen among all possible valid outputs.
+ +How can this best be implemented in a quantum algorithm ?
+ +A solution for this is already proposed as part of one of the answers for How to create a quantum algorithm that produces 2 n-bit sequences with equal number of 1-bits?. But the problem with this solution is that this requires about $\binom{n}2$ help qubits which becomes rapidly huge if n is big.
+ +Note:
+ +-
+
- Please, do not provide a classical algorithm without any explanation of how the steps of the classical algorithm can be mapped to a universal quantum computer. +
- for me there are 2 good ways to interpret ""randomly chosen among all possible good outputs"": (1) each possible good output has equal chance of being chosen. (2) every possible good output has a chance > 0 of being chosen. +
During the classical pre-processing stage of Simon's algorithm, we repeat the quantum operations $n-1$ times to get
+ +$$ +\begin{alignat}{7} +y_{1} \cdot s & \phantom{\vdots} =~ && 0 \\ y_{2} \cdot s & \phantom{\vdots}=~ && 0 \\ & \phantom{=} \vdots \\ y_{n-1} \cdot s & \phantom{\vdots}=~ && 0 ~, +\end{alignat} +$$
+ +where $s$ is the period while $y_{i}$ are the linearly independent measurement outcomes of the quantum process. But, shouldn't we be requiring $n$ equations to get the value of $s$ as it is an unknown with $n$ variables? I wonder if this is because a system of $n$ equations will admit only the trivial solution of all $0$s. Is there a mathematical reasoning to elucidate this? How exactly would we uniquely solve for $n$ variables with $n-1$ equations?
+",1351,,15,,06-04-2018 00:04,06-04-2018 00:04,Simon's algorithm: Number of equations,Imagine for a moment that $y_1,\ldots,y_{n-1}$ are linearly independent vectors in $\mathbb{R}^n$. There would then be a one-dimension subspace of vectors $s$ satisfying the $n-1$ equations you listed.
+ +The situation is the same here, except that the field of real numbers is replaced by the finite field $\mathbb{F}_2$ with elements 0 and 1. The same linear algebra as in the real number case works in this case, and we again obtain a one-dimensional subspace of possible solutions $s$. This time, however, because there are only two elements of $\mathbb{F}_2$, this one-dimensional subspace includes only two elements: the all-zero vector and some nonzero vector $s$. Naturally we disregard the all-zero vector and take the nonzero vector $s$ as our solution.
+ +Note also that if you did add another equation, $y_n\cdot s = 0$ for some $y_n$, then $y_n$ would have to be a linear combination of $y_1,\ldots,y_{n-1}$, for otherwise the only solution would be $s = (0,\ldots,0)$. So, you would not obtain any additional information about $s$ by adding an additional equation.
+",1764,,,,,06-03-2018 18:18,,,,0,,,,CC BY-SA 4.0 +2225,1,,,06-04-2018 01:53,,8,564,"This is probably just a misunderstanding on my part, but everything I've seen on what quantum computers do thus far seems to suggest that the actual process of reading the entangled qubits would be equivalent to reading the value of a plate opposing a subdivided plate in a plate capacitor while the setting of initial qubits would be the equivalent of assigning a voltage to each subdivided plate. E.g. in this image:
+ +You would be able to read the voltage on the red plate after setting independent voltages from a known range representing 0 at the low and 1 at the high on the 4 separate subdivisions of the opposing plate, then rounding off at some particular voltage to get a zero or one out of it for those 4 bits.
+ +Is this wrong? If so, how does it differ from actual quantum computing?
+",2538,,26,,12/23/2018 12:29,12/23/2018 12:29,What's the difference between a set of qubits and a capacitor with a subdivided plate?,Your capacitors cannot be in the state $\frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$, but qubits can.
+ +Let's say $|0\rangle$ is 0$\,$V and $|1\rangle$ is 1$\,$V.
+If you have 2 bits we can have $|00\rangle$,$|01\rangle$,$|10\rangle$,$|11\rangle$.
But the state: $\frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$, is in a superposition of two of these cases. The bit values can be (0,0) or (1,1). Either case is equally possible, until a measurement is made (think Schrödinger's cat: you don't know if it's alive or dead until you open the box).
+",2293,,2293,,07-08-2018 01:31,07-08-2018 01:31,,,,6,,,,CC BY-SA 4.0 +2227,1,,,06-04-2018 05:46,,7,182,"I have been reading the paper A quantum-implementable neural network model (Chen et al., 2017) for a few days now, but failed to understand how exactly their algorithm offers a speedup over the classical neural network models.
+In particular I'm confused about what they mean by and what they are trying to do with quantum multiplexers. They haven't even defined it properly.
+Here's the relevant paragraph:
+++One of the most interesting points of QPNN is that we can use quantum parallelism to combine several basic networks at the same time. To achieve this purpose, only $n$ qubits are needed in a control layer to perform the following quantum multiplexer as shown in Fig. $5$.
+$$\left( \begin{array}{ccc} U_1 \\ & \ddots \\ && U_{2^n} \end{array} \right) \tag{13}$$ +
+
++where $U_i$ represents the dynamics of the $i$th basic network. Moreover $2^{n}$ different quantum gates $\left\{P^{(i)}|i=1, \dots ,2^{n}\right\}$ can also be applied on the output layer of each basic network respectively.
+
Questions:
+-
+
- What does $i^{\text{th}}$ basic network mean in this context? +
- What is quantum multiplexer and how exactly is it helping in this context? What is meant by the matrix shown in $(13)$? (I read a few papers on quantum multiplexers which say that they are basically used to transfer information contained by several qubits as information in a qudit. But no idea how that is relevant here.) +
- What do they mean by "we can use quantum +parallelism to combine several basic networks at the same time"? +
I would like to simulate a quantum algorithm where one of the steps is ""Square root of Swap gate"" between 2 qubits.
+ +How can I implement this step using the IBM composer?
+",2529,,26,,12/23/2018 13:45,02-06-2020 22:02,"How to implement the ""Square root of Swap gate"" on the IBM Q (composer)?",I know we already have an answer here, but going back to the problem specification, there's a much simpler way to achieve this if the only thing that's important is the output, comprising a binary string. All the protocol actually has to do is:
+ +-
+
Select an $n$-bit string, $x\in\{0,1\}^n$ at random. If you don't want to trust classical randomness, use $n$ qubits, starting in $|0\rangle$, with Hadamard acting on them, and measure in the computational basis. In fact, just use 1 qubit, and repeat the same thing $n$ times with it.
+Let $w_x$ be the Hamming weight of $x$ (i.e. the number of 1s). Select a random $y\in\{0,1\}^n$ such that $w_y=w_x$. There are several ways you might do this, but, for example, use $m=\lceil\log_2\binom{n}{w_x}\rceil$ bits. Generate an answer $z\in\{0,1\}^m$ uniformly at random (i.e. $p_z=1/2^m$). $\binom{n}{w_x}$ of these strings $z$ can be mapped onto a suitable $y$. If a given answer cannot, just keep choosing a random $z$ until it can. On average, you won't need more than 2 gos.
+Give the answer $x,y$.
+
In order to rotate about an axis of the Bloch sphere we ususally use pulses e.g. in trapped ion quantum computing or superconducting qubits. Let's say we have rotation around the x-axis. What do I have to change in order to be able to rotate around the y-axis or the z-axis? I assume it has something to do with the phase but I could not find a good reference for how this works.
+",1853,,26,,12/23/2018 13:44,01-06-2019 14:27,Rotating about the y- or z-axis of the Bloch sphere,A quantum computer can do classical computations. +The optimal algorithm would be to:
+ +-
+
- Pick any bit (the fastest one you can get access to). +
- Find a bit that has the opposite value (if in step 1 you got a 0, find a 1) +
- Switch them (0 becomes 1 and 1 becomes 0). +
Step 2 involves searching through an $N$ bit string which using classical operations takes $\mathcal{O}(N)$ operations, but if you can get the $n^{\textrm{th}}$ bit value by evaluating a function, you may be able to use Grover's quantum algorithm to find the opposite bit with $\mathcal{O}\left(\sqrt{N}\right)$ operations.
+",2293,,,,,06-04-2018 12:45,,,,1,,,,CC BY-SA 4.0 +2233,2,,2222,06-04-2018 14:54,,5,,"It could be done with $\lceil\log n\rceil$ additional qubits along these lines:
+ +++ ++
+- +
Transform the additional qubits so that they encode a number + $k\in\{0,\ldots,n-1\}$ chosen uniformly at random.
- +
Cyclically shift the input qubits $k$ times.
- +
Let the last of the original input qubits be fixed as an output and recurse on the remaining $n-1$ of them.
This is a classical algorithm, but you can run it on a quantum computer of course, as Norbert has suggested in a comment. (The aspect of the question that is adamant about the algorithm being quantum is still not clear to me, so if running a classical algorithm such as the one I have suggested on a quantum computer is not sufficient, it would be helpful for the question to be clarified.)
+ +Note that because the question asks for a random output, the algorithm is going to have to generate entropy at some point, presumably through measurements or performing other non-unitary operations on qubits (such as initializing them). In the algorithm above, it is the first step that generates entropy: regardless of the state of the additional qubits before the operation in step 1 is performed, they should have the state +$$ +\frac{1}{n} \sum_{k = 0}^{n-1} \lvert k \rangle \langle k \rvert +$$ +after step 1 is performed (with $k$ encoded in binary, let's say).
+",1764,,,,,06-04-2018 14:54,,,,5,,,,CC BY-SA 4.0 +2234,2,,2228,06-04-2018 16:49,,0,,"Every 2-qubit gate has a ""Paulinomial decomposition"" which means it can be written as a polynomial of Pauli matrices.
+ +For the gate you want:
+ +$ +\sqrt{ \mbox{SWAP} } = +\begin{bmatrix} +1 & 0 & 0 & 0 \\ +0 & \frac{1}{{2}} (1+i) & \frac{1}{{2}} (1-i) & 0 \\ +0 & \frac{1}{{2}} (1-i) & \frac{1}{{2}} (1+i) & 0 \\ +0 & 0 & 0 & 1 \\ +\end{bmatrix} = \frac{1-i}{4}\left(X_1X_2+Y_1Y_2+Z_1Z_2\right) +\frac{3+i}{2}I, +$
+ +where $X_i$ is an $X$ gate applied to the $i^\textrm{th}$ qubit.
+",2293,,2293,,06-04-2018 16:59,06-04-2018 16:59,,,,10,,,,CC BY-SA 4.0 +2235,2,,2228,06-04-2018 22:42,,11,,"Here is a SQRT(SWAP) construction which only requires CNOTs in one direction, Hadamards, S gates ($Z^{\frac{1}{2}}$), S dagger gates ($Z^{-\frac{1}{2}}$), T gates ($Z^{\frac{1}{4}}$) and T dagger gates ($Z^{-\frac{1}{4}}$):
+ +You should be able to encode it directly into the composer.
+",119,,-1,,02-06-2020 22:02,02-06-2020 22:02,,,,16,,,,CC BY-SA 4.0 +2236,2,,2228,06-04-2018 23:22,,5,,"What you want to do is a rotation on the subspace spanned by $|01\rangle$ and $|10\rangle$ which rotates it by $\sqrt{X}$. To this end, you can first do a CNOT, which maps this subspace to $\{|01\rangle,|11\rangle\}$. Now you need to do the $\sqrt{X}$ rotation on the first qubit, conditioned on the second qubit being one. Implementing controlled-$U$ gates using CNOTs is a standard construction, which can be found in a range of places, see e.g. https://arxiv.org/abs/quant-ph/9503016. Depending how you do this step, you might have to fix the ""global"" phase of the 1st qubit (given the 2nd is $|1\rangle$). Finally, you need to undo the CNOT.
+",491,,,,,06-04-2018 23:22,,,,5,,,,CC BY-SA 4.0 +2237,2,,2225,06-05-2018 09:46,,2,,"It looks like you are asking about the possibility of encoding the mathematics of quantum states & measurement into some kind of analog device. And yes, I think this is possible. This reminds me of how people study analog models of gravity. The one problem I can see with this is that it will not scale very well as you increase the number of entangled quantum systems. Eg. for every extra qubit added to a system you double the number of dimensions. So for 10 qubits you would need a capacitor plate with 1024 subdivisions, and so on.
+ +In summary, what you are proposing is to simulate a quantum system with an analog computer. We already do this with digital computers, but it just doesn't scale.
+",263,,,,,06-05-2018 09:46,,,,0,,,,CC BY-SA 4.0 +2238,1,2241,,06-05-2018 09:59,,8,544,"I am learning how to program the IBM Q Experience quantum computers in order to learn more about how does it work and in order to perform some experiments in it. By doing so I was wondering what are the most advanced things that have been done in such computers that actually are an advance for quantum technologies.
+ +More specfically, I am interested in what have been done in quantum error correction code implementation and testing in those, and if some papers about those implementations and techniques used are available.
+",2371,,26,,12/13/2018 19:51,12/13/2018 19:51,Practical Implementations of QECCs in IBM Q Experience,Note: this answer assumes you want the permutation to be coherent, i.e. you want $\frac{1}{\sqrt{3}} ( |001\rangle + |010\rangle + |100\rangle)$ instead of a 1/3 chance of $001$, a 1/3 chance of $010$, and a 1/3 chance of $100$.
+ +Be careful how you specify this task, because it could very easily be impossible due to reversibility constraints. For example, for the input $|001\rangle$ you want to output the GHZ state $\left| {3 \atop 1} \right\rangle = \frac{1}{\sqrt{3}} (|001\rangle + |010\rangle + |100\rangle)$. But if you also want to output the GHZ state for the input $|010\rangle$ and $|100\rangle$, that won't work. You can't send multiple input states to the same output state (without decoherence). As long as you say ""I only care about sorted-ascending inputs like 0000111 but not 1110000 or 0010110; you can do whatever you want with those"", this will be fine.
+ +One trick to producing a quantum permutation of a sorted input is to first prepare a ""permutation state"" by applying a sorting network to a list of seed values each in a uniform superposition. The sorting network will output qubits holding the sorted seeds, but also qubits holding the sorting network comparisons. The permutation state is just the comparison qubits. To apply it to your input, you simply run the input through the sorting network in reverse. Note that there are some tricky details here; see the paper ""Improved Techniques for Preparing Eigenstates of Fermionic Hamiltonians"". You would have to generalize this technique to work on inputs with repeated values, instead of only unique values.
+ +You may also want to look into ""quantum compression"", which is very closely tied to the $\left| {n \atop k} \right\rangle$ states (uniform superpositions of all $n$-bit states with $k$ bits set) that you want to produce. The main difference is that you would run the quantum compression circuit in reverse, and it expects a number encoding ""how many ones are there?"" instead of ""give me a state with the correct number of ones"".
+ +I guess what I'm saying is that producing these kinds of states is more complicated than you might have expected. I think the reason it is complicated is because the magnitude of the amplitudes in your outputs depend on the computational basis state of your input. For example, for $|0001\rangle$ you want an output which is a superposition of four classical states, so you have a prefactor of $\frac{1}{\sqrt{4}}$ hidden inside $\left| {4 \atop 1} \right\rangle$. But for $|0011\rangle$ the desired output has six classical states and so $\left| {4 \atop 2} \right\rangle$ hides a prefactor of $\frac{1}{\sqrt{6}}$.
+",119,,119,,06-05-2018 12:17,06-05-2018 12:17,,,,2,,,,CC BY-SA 4.0 +2240,2,,2238,06-05-2018 12:12,,2,,"You might find the paper ""Automated Error Correction in IBM Quantum Computer and Explicit Generalization"" (2017) by Panigrahi et al. relevant. As for ""what are the most advanced things that have been done in such computers that actually are an advance for quantum technologies"", if you search a bit on arXiv you'll find quite a few relevant papers published by them. One such recent example which I personally had found quite interesting is: ""Application of quantum scrambling in Rydberg atom on IBM quantum computer"" (2018).
+ +Disclosure: I'm currently an undergraduate member of Prof. Panigrahi's group.
+",26,,26,,06-05-2018 12:29,06-05-2018 12:29,,,,0,,,,CC BY-SA 4.0 +2241,2,,2238,06-05-2018 13:13,,4,,"The publicly available IBM devices don't yet have the connectivity to realize quantum error correcting codes that both detect and correct a full set of quantum errors. But we can certainly do proof-of-principle experiments on the tools and techniques required. Here are the experiments I know of
+ +Error correction experiments done (or doable) on a 5 qubit device:
+ +-
+
- Detecting arbitrary quantum errors via stabilizer measurements on a sublattice of the surface code +
- Is error detection helpful on IBM 5Q chips? +
- Experimental demonstration of fault-tolerant state preparation with superconducting qubits +
- Protecting quantum memories using coherent parity check codes +
Error correction experiments on the 16 qubit device.
+ + + +Disclosure: The last one is mine.
+",409,,,,,06-05-2018 13:13,,,,1,,,,CC BY-SA 4.0 +2242,1,,,06-05-2018 14:22,,11,2833,"I was wondering if there is a way to compose a program with multiple quantum circuits without having the register reinitialized at $0$ for each circuit.
+ +Specifically, I would like run a second quantum circuit after running the first one, as in this example:
+ +qp = QuantumProgram()
+qr = qp.create_quantum_register('qr',2)
+cr = qp.create_classical_register('cr',2)
+
+qc1 = qp.create_circuit('B1',[qr],[cr])
+qc1.x(qr)
+
+qc1.measure(qr[0], cr[0])
+qc1.measure(qr[1], cr[1])
+
+qc2 = qp.create_circuit('B2', [qr], [cr])
+qc2.x(qr)
+qc2.measure(qr[0], cr[0])
+qc2.measure(qr[1], cr[1])
+
+#qp.add_circuit('B1', qc1)
+#qp.add_circuit('B2', qc2)
+
+pprint(qp.get_qasms())
+
+result = qp.execute()
+
+print(result.get_counts('B1'))
+print(result.get_counts('B2'))
+Unfortunately, what I get is the same result for the two runs (i.e. a count of 11 for the B1 and B2 instead of 11 and 00 for the second, as if B2 is run on a completely new state initialized on 00 after B1.
Once you do a measurement, the wavefunction of the quantum state/register collapses and it loses its quantum nature. It doesn't make sense to apply another circuit on it.
+",2527,,,,,06-05-2018 17:49,,,,3,,,,CC BY-SA 4.0 +2244,1,,,06-05-2018 21:39,,20,881,"In boson sampling, if we start with 1 photon in each of the first $M$ modes of an interferometer, the probability of detecting 1 photon in each output mode is: $|\textrm{Perm}(A)|^2$, where the columns and rows of $A$ are the first $M$ columns of the interferometer's unitary matrix $U$, and all of its rows.
+ +This makes it look like for any unitary $U$, we can construct the appropriate interferometer, construct the matrix $A$, and calculate the absolute value of the permanent of $A$ by taking the square root of the probability of detecting one photon in each mode (which we get from the boson sampling experiment). Is this true, or is there some catch? People have told me that you can't actually get information about a permanent from boson sampling.
+ +Also, what happens to the rest of the columns of $U$: How exactly is it that the experimental outcome only depends on the first $M$ columns of $U$ and all of its rows, but not at all on the other columns of $U$? Those columns of $U$ do not affect the outcome of the experiment in the first $M$ modes at all?
+",2293,,55,,09-10-2020 11:47,09-10-2020 11:47,"Is it possible to ""calculate"" the absolute value of a permanent using Boson Sampling?",It appears to be true, up to a point. As I read Scott Aaronson's paper, it says that if you start with 1 photon in each of the first $M$ modes of an interferometer, and find the probability $P_S$ that a set $s_i$ photons is output in each mode $i\in\{1,\ldots, N\}$ where $\sum_is_i=M$, is +$$ +P_s=\frac{|\text{Per(A)}|^2}{s_1!s_2!\ldots s_M!}. +$$ +So, indeed, if you take a particular instance where $s_i=0$ or 1 for every possible output, then, yes the probability is equal to the permanent of $A$, where $A$ is the first $M$ columns of $U$ and a specific subset of $M$ rows specified by the locations $s_i=1$. So, this is not quite as specified in the question: it is not all rows, but only some subset, so that $A$ is a square matrix, corresponding to the bits that the experiment ""sees"", i.e. the input rows and output rows. The photons never populate anything else, and so are blind to the other elements of the unitary matrix $U$.
+ +This should be fairly obvious. Let's say I have some $3\times 3$ matrix $V$. If I start in some basis state $|0\rangle$ and find its product, $V|0\rangle$, then knowing that tells me very little about the outputs $V|1\rangle$ and $V|2\rangle$, aside from what can be said from the knowledge that $V$ is unitary, and hence columns and rows are orthonormal.
+ +The issue that one must be careful of is the accuracy: you run this once and all you get is a single sample according to the probability distribution $P_s$. You run this a few times, and you start to build up information about the different probabilities. You run this enough times, and you can get an arbitrarily accurate answer, but how many is enough? There are two different ways that you can measure the error in an estimate of a value $p$. You can demand either an additive error $p\pm\epsilon$ or a multiplicative error, $p(1\pm\epsilon)$. Since we expect that a typical probability will be exponentially small in $n+m$, the multiplicative error demands far greater accuracy, which cannot be achieved efficiently via sampling. On the other hand, the additive error approximation can be achieved.
+ +While a multiplicative error is what people usually want to calculate, the additive error can also be an interesting entity. For example, in the evaluation of the Jones polynomial.
+ +Aaronson points us back further in time for where this connection between Boson sampling and the Permanent was first made:
+ +++ +It has been known since work by Caianiello in 1953 (if not earlier) that the amplitudes for $n$-boson processes can be written as the permanents of $n\times n$ matrices.
+
Instead, their main contribution
+ +++ +is to prove a connection between the ability of classical computers to solve the approximate + BosonSampling problem and their ability to approximate the permanent
+
i.e. to understand the approximation problem associated with, e.g. finite sampling, and to describe the computational complexity consequences associated: that we believe such a thing is hard to evaluate classically.
+",1837,,1837,,06-07-2018 06:54,06-07-2018 06:54,,,,6,,,,CC BY-SA 4.0 +2246,2,,2244,06-06-2018 10:56,,7,,"You cannot efficiently recover the absolute values of the amplitudes, but if you allow for arbitrary many samples, then you can estimate them to whatever degree of accuracy you like.
+ +More specifically, if the input state is a single photon in each of the first $n$ modes, and one is willing to draw an arbitrary number of samples from the output, then it is in principle possible to estimate the permanent of $A$ to whatever degree of accuracy one likes, by counting the fraction of the times the $n$ input photons come out in the first $n$ different output ports. +It is to be noted though that this does not really have much to do with BosonSampling, as the hardness result holds in the regime of the number of modes much larger than the number of photons, and it's about the efficiency of the sampling.
+ +BosonSampling
+ +I'll try a very brief introduction to what boson sampling is, but it should be noted that I cannot possibly do a better job at this than Aaronson himself, so it's probably a good idea to have a look at the related blog posts of his (e.g. blog/?p=473 and blog/?p=1177), and links therein.
+ +BosonSampling is a sampling problem. This can be a little bit confusing in that people are generally more used to think of problems having definite answers. +A sampling problem is different in that the solution to the problem is a set of samples drawn from some probability distribution.
+ +Indeed, the problem a boson sampler solves is that of sampling from a specific probability distribution. More specifically, sampling from the probability distribution of the possible outcome (many-boson) states.
+ +Consider as a simple example a case with 2 photons in 4 modes, and let's say we fix the input state to be $(1,1,0,0)\equiv|1,1,0,0\rangle$ (that is, a single photon in each of the two first two input modes). +Ignoring the output states with more than one photon in each mode, there are $\binom{4}{2}=6$ possible output two-photon states: +$(1,1,0,0), (1,0,1,0), (1,0,0,1), (0,1,1,0), (0,1,0,1)$ and $(0,0,1,1)$. +Let us denote for convenience with $o_i, i=1,.,6$ the $i$-th one (so, for example, $o_2=(1,0,1,0)$). +Then, a possible solution to BosonSampling could be the series of outcomes: +$$o_1, o_4, o_2, o_2, o_5.$$
+ +To make an analogy to a maybe more familiar case, it's like saying that we want to sample from a Gaussian probability distribution. +This means that we want to find a sequence of numbers which, if we draw enough of them and put them into a histogram, will produce something close to a Gaussian.
+ +Computing permanents
+ +It turns out that the probability amplitude of a given input state $|\boldsymbol r\rangle$ to a given output state $|\boldsymbol s\rangle$ is (proportional to) the permanent of a suitable matrix built out of the unitary matrix characterizing the (single-boson) evolution.
+ +More specifically, if $\boldsymbol R$ denotes the mode assignment list${}^{(1)}$ associated to $|\boldsymbol r\rangle$, $\boldsymbol S$ that of $|\boldsymbol s\rangle$, and $U$ is the unitary matrix describing the evolution, then the probability amplitude $\mathcal A(\boldsymbol r\to\boldsymbol s)$ of going from $|\boldsymbol r\rangle$ to $|\boldsymbol s\rangle$ is given by +$$\mathcal A(\boldsymbol r\to\boldsymbol s) = +\frac{1}{\sqrt{\boldsymbol r!\boldsymbol s!}} \operatorname{perm} U[\boldsymbol R|\boldsymbol S], +$$ +with $U[\boldsymbol R|\boldsymbol S]$ denoting the matrix built by taking from $U$ the rows specified by $\boldsymbol R$ and the columns specified by $\boldsymbol S$.
+ +Thus, considering the fixed input state $|\boldsymbol r_0\rangle$, the probability distribution of the possible outcomes is given by the probabilities +$$p_{\boldsymbol s} = \frac{1}{\boldsymbol r_0! \boldsymbol s!} \lvert +\operatorname{perm}U[\boldsymbol R|\boldsymbol S] +\rvert^2.$$
+ +BosonSampling is the problem of drawing ""points"" according to this distribution.
+ +This is not the same as computing the probabilities $p_s$, or even computing the permanents themselves. +Indeed, computing the permanents of complex matrices is hard, and it is not expected even for quantum computers to be able to do it efficiently.
+ +The gist of the matter is that sampling from a probability distribution is in general easier than computing the distribution itself. +While a naive way to sample from a distribution is to compute the probabilities (if not already known) and use those to draw the points, there might be smarter ways to do it. +A boson sampler is something that is able to draw points according to a specific probability distribution, even though the probabilities making up the distribution itself are not known (or better said, not efficiently computable).
+ +Furthermore, while it may look like the ability to efficiently sample from a distribution should translate into the ability of efficiently estimating the underlying probabilities, this is not the case as soon as there are exponentially many possible outcomes. +This is indeed the case of boson sampling with uniformly random unitaries (that is, the original setting of BosonSampling), in which there are $\binom{m}{n}$ possible $n$-boson in $m$-modes output states (again, neglecting states with more than one boson in some mode). For $m\gg n$, this number increases exponentially with $n$. +This means that, in practice, you would need to draw an exponential number of samples to even have a decent chance of seeing a single outcome more than once, let alone estimate with any decent accuracy the probabilities themselves (it is important to note that this is not the core reason for the hardness though, as the exponential number of possible outcomes could be overcome with smarter methods).
+ +In some particular cases, it is possible to efficiently estimate the permanent of matrices using a boson sampling set-up. This will only be feasible if one of the submatrices has a large (i.e. not exponentially small) permanent associated with it, so that the input-output pair associated with it will happen frequently enough for an estimate to be feasible in polynomial time. This is a very atypical situation, and will not arise if you draw unitaries at random. For a trivial example, consider matrices that are very close to identity - the event in which all photons come out in the same modes they came in will correspond to a permanent which can be estimated experimentally. Besides only being feasible for some particular matrices, a careful analysis of the statistical error incurred in evaluating permanents in this way shows that this is not more efficient than known classical algorithms for approximating permanents (technically, within a small additive error) ${}^{(2)}$.
+ +Columns involved
+ +Let $U$ be the unitary describing the one-boson evolution. +Then, basically by definition, the output amplitudes describing the evolution of a single photon entering in the $k$-th mode are in the $k$-th column of $U$.
+ +The unitary describing the evolution of the many-boson states, however, is not actually $U$, but a bigger unitary, often denoted by $\varphi_n(U)$, whose elements are computed from permanents of matrices built out of $U$.
+ +Informally speaking though, if the input state has photons in, say, the first $n$ modes, then naturally only the first $n$ columns of $U$ must be necessary (and sufficient) to describe the evolution, as the other columns will describe the evolution of photons entering in modes that we are not actually using.
+ ++ +
(1) This is just another way to describe a many-boson state. Instead of characterizing the state as the list of occupation numbers for each mode (that is, number of bosons in first mode, number in second, etc.), we characterize the states by naming the mode occupied by each boson. +So, for example, the state $(1, 0, 1, 0)$ can be equivalently written as $(1, 3)$, and these are two equivalent ways to say that there is one boson in the first and one boson in the third mode.
+ +(2): S. Aaronson and T. Hance. ""Generalizing and Derandomizing Gurvits's Approximation Algorithm for the Permanent"". https://eccc.weizmann.ac.il/report/2012/170/
+",55,,55,,8/16/2018 9:03,8/16/2018 9:03,,,,8,,,,CC BY-SA 4.0 +2247,2,,2004,06-06-2018 12:50,,4,,"Grover's algorithm is used extensively in quantum cryptography as well. It can be used to solve problems such as the Transcendental Logarithm Problem, Polynomial Root Finding Problem etc.
+",2556,,,,,06-06-2018 12:50,,,,2,,,,CC BY-SA 4.0 +2248,1,,,06-06-2018 13:08,,10,1118,"D-Wave makes use of a $(n,k=4)$-Chimera structured graph in their computers. Meaning a $n\times n$ grid of unit cells, with each unit cell consisting of a complete bipartite graph on $2k=8$ nodes ($4$ for each side), also called $K_{4,4}$.
+ +Why did D-Wave chose $k=4$? An argument given is that this non-planar structure allows for an embedding of many interesting problems. However, $K_{3,3}$ is also a non-planar graph. So why not choose $k=3$? Additionally, increasing $k$ seems to me as one of the easiest ways to increase the number of qubits your problem has. So why not use $k=5,6,\dots$?
+",2005,,2293,,06-06-2018 23:41,10/21/2018 3:51,Why did D-Wave choose the Chimera graph the way they did?,You are right that $K_{3,3}$ is non-planar, but as you said yourself, a larger $k$ is much better. If they could do $K_{1000,1000}$ that would be nice, because each qubit could be coupled to 1002 qubits (1000 within the $K_{1000,1000}$ and two to the neighboring cells). Instead D-Wave is limited to problems which can be embedded such that each qubit couples to at most 6 other qubits.
+ +The reason they don't have larger $k$ is for physical reasons. It is harder to couple a qubit to 1002 qubits than it is to couple it to 6 qubits. It is also harder to couple a qubit to 6 qubits vs 5 qubits, but they found that it was easy enough to go to $k=4$, so they were not limited to $K_{3,3}$.
+",2293,,2293,,06-06-2018 23:42,06-06-2018 23:42,,,,5,,,,CC BY-SA 4.0 +2251,1,2253,,06-06-2018 19:10,,5,3046,"How would you check if 2 qubits are orthogonal with respect to each other?
+ +I need to know this to solve this problem:
+ +++",2559,,26,,12/23/2018 12:29,12/23/2018 12:29,How to check if 2 quantum bits are orthogonal?,You are given $2$ quantum bits:$$ +\begin{align} +|u_1\rangle &= \cos\left(\frac{x}{2}\right) |0\rangle + \sin\left(\frac{x}{2}\right)e^{in} |1\rangle \tag{1} \\[2.5px] +|u_2\rangle &= \cos\left(\frac{y}{2}\right) |0\rangle + \sin\left(\frac{y}{2}\right)e^{im} |1\rangle \tag{2} +\end{align} +$$where $m-n = \pi$ and $x+y=\pi$.
+
In order to check if two qubits are orthogonal, you should check that the inner product between them equals zero. This can be written like +$\langle u_1|u_2\rangle=0$.
+ +Knowing that $\langle 0|0\rangle=1$, $\langle 0|1\rangle=0$, $\langle 1|0\rangle=0$ and $\langle 1|1\rangle=1$ it should be easy to solve the problem by yourself.
+",2371,,,,,06-06-2018 19:32,,,,2,,,,CC BY-SA 4.0 +2253,2,,2251,06-07-2018 06:14,,4,,"Keep in mind that $|0\rangle$ and $|1\rangle$ are orthonormal basis vectors of a two-dimensional complex vector space (over the field of complex numbers). To check whether $|u_1\rangle$ and $|u_2\rangle$ are orthogonal you'll have to check whether the standard inner product $\langle u_1|u_2\rangle$ is $0$. Here $\langle u_1|$ refers to the bra vector corresponding to the ket vector $|u_1\rangle$. In matrix notation that would simply mean that $\langle u_1|$ is the complex conjugate transpose a.k.a Hermitian conjugate of $|u_1\rangle$.
+ +In your case:
+ +$|u_1\rangle = \cos(\frac{x}{2}) \begin{bmatrix} 1 \\ 0 \end{bmatrix} + (\sin(\frac{x}{2}))e^{in} \begin{bmatrix} 0 \\ 1 \end{bmatrix}$
+ +and
+ +$|u_2\rangle = \cos(\frac{y}{2}) \begin{bmatrix} 1 \\ 0 \end{bmatrix} + (\sin(\frac{y}{2}))e^{im} \begin{bmatrix} 0 \\ 1 \end{bmatrix}$
+ +Now, you'll find $\langle u_1|$ to be:
+ +$\cos(\frac{x}{2}) \begin{bmatrix} 1 & 0 \end{bmatrix} + (\sin(\frac{x}{2}))e^{-in} \begin{bmatrix} 0 & 1 \end{bmatrix}$
+ +Now, simply carry out the multiplication of the matrices $\langle u_1|$ and $ |u_2\rangle$. If it turns out to be $0$, they're orthogonal. Or else they're not orthogonal.
+",26,,,,,06-07-2018 06:14,,,,0,,,,CC BY-SA 4.0 +2254,2,,2251,06-07-2018 07:08,,4,,"Instead of doing matrix calculation you can also map those qubits to the Bloch sphere. A Bloch sphere is a unit 2-sphere, with antipodal points corresponding to a pair of mutually orthogonal state vectors.
+ +So if you can show that the 2 points are antipodal on a Bloch sphere, then you have proven that they are orthogonal.
+ +The nice thing is that your qubits are already expressed in a way that can easily be mapped on the bloch sphere (x, y, n and m correspond to the angles on the Bloch sphere).
+ +So giving the angles it is easy to determine if they are antipodal as in that case the corresponding angles must differ with $\pi + n.2\pi$ where n is a positive or negative natural number (note that in case $\theta =0 + n\pi$ is a special case as in that case we should ignore angle $\psi$).
+ +In the question it is already stated that the angles m and n differ with $\pi$ so we only need to look at the angles x and y and so we can conclude that only under the following condition will the above 2 qubits be orthogonal
+ +-
+
- $y-x = { \pi + n (2 \pi)}$ where $n$ is a positive or negative natural number [1] +
As $x+y= \pi$ (see question) and [1] : then only the following x and y combinations will give orthogonal qubits.
+ +-
+
- $2y = \pi + \pi + n (2 \pi)$ which can be simplified as $y = n\pi$ where n is a positive or negative natural number and in that case $x=\pi - n\pi$ (e.g. when $y=0$ en $x=\pi$ we get 2 orthogonal qubits). +
I'm currently reading Nielsen and Chuang's Quantum Computation and Quantum Information and I'm not sure if I correctly understand this exercise (on page 57) :
+++Exercise 1.2: Explain how a device which, upon input of one of two non-orthogonal quantum states $\left|\psi\right>$ or $\left|\phi\right>$ correctly identified the state, could be used to build a device which cloned the states $\left|\psi\right>$ and $\left|\phi\right>$, in violation of the no-cloning theorem. Conversely, explain how a device for cloning could be used to distinguish non-orthogonal quantum states.
+
The first part seems fairly straightforward to me : once the state has been identified as $|\psi\rangle$ or $|\phi\rangle$, just prepare an identical state through whatever means we have available, effectively cloning the original state.
+For the converse, I've not been able to achieve better than this :
+-
+
Clone the state to be identified $n$ times
+
+Perform a measurement on each of the copies in the basis $(|\psi\rangle, |\psi'\rangle)$, where $|\psi'\rangle$ is a state orthogonal to $|\psi\rangle$
+
+If one of the measurements yields $|\psi'\rangle$, then we know for certain that the original state is $|\phi\rangle$
+
+If all of the measurements yield $|\psi\rangle$, we can claim that the original state is $|\psi\rangle$ with a probability of error equal to : $|\langle\psi|\phi\rangle|^{2n}$, which can be made arbitrarily small by increasing $n$
+
+
However, the way the exercise is worded makes me think that there must be some deterministic way of distinguishing between $|\psi\rangle$ and $|\phi\rangle$ given a cloning machine. Is this indeed the case?
+",2563,,2563,,02-11-2021 18:03,02-11-2021 18:03,No-cloning theorem and distinguishing between two non-orthogonal quantum states,That's the way that I would initially go about answering the question. There are, however, a few tweaks you could make.
+ +Definitive Answer
+ +As you point out, the annoying feature is that you can never be definitive about having the state $|\psi\rangle$.
+ +There are a couple of ways that you might avoid that pitfall.
+ +The first option is to have two different measurement bases that you pick between. The first is as you specified. The second is the complementary view where you use $(|\phi\rangle,|\phi'\rangle)$.
+ +The second option is to introduce a POVM. (I don't have my copy of Nielsen and Chuang to hand, and don't remember if they've been introduced at this point.) POVMs can have more than 2 measurement operators, and are often quite good at saying ""the state was definitely not $|x\rangle$"", so you could make one operator that says ""the state definitely was not $|\psi\rangle$"", another that says ""definitely not $|\phi\rangle$"" and a third just for the sake of completeness.
+ +Both options are variants on a theme, and technically you might still have to run both forever before you get a definitive answer, but the expected number of trials is finite.
+ +Better Outcome Probabilities
+ +You can actually pick a better measurement basis than the one you described so that you can come to a conclusion faster (but certainly does not give you a definitive answer). Try to think about the two states $|\psi\rangle$ and $|\phi\rangle$ on the Bloch sphere. You can always find a plane passing through both points and the centre of the sphere. On this plane, there is a circle, with two points corresponding to the two states. Draw lines joining these points to the centre. Next, construct a diameter of the circle which makes equal angles with the two lines you've just drawn. This would define the measurement basis that tells you absolutely nothing about which of the two states you have. But, if you construct the diameter that is perpendicular to that line, this is the one that, at least in a single shot, has the maximum probability of distinguishing between the two states.
+ +Here's a picture. $|\Psi\rangle$ is one of the two basis states that you want for the measurement, and remember that the angle $\theta$ can be related to $|\langle\psi|\phi\rangle|$.
+
It might be worth then calculating if you have $k$ copies of each state, whether a joint measurement constructed in this way can perform better than the individual measurement repeated $k$ times.
+",1837,,1837,,06-07-2018 11:53,06-07-2018 11:53,,,,0,,,,CC BY-SA 4.0 +2257,2,,2251,06-07-2018 13:51,,7,,"The answers given so far assume that classical descriptions of the two qubits' states are given (e.g. x and y are provided in the problem's statement). Interestingly, even if the two states are unknown to you, the overlap of the two qubits' states can be evaluated with a simple quantum circuit, provided you have access to pairs of qubits in these states. The circuit is known as a SWAP test, and can be found in Fig. 1 of this reference 1, where apparently it was first proposed.
+ +1 Buhrman et al., ""Quantum fingerprinting"". https://arxiv.org/abs/quant-ph/0102001
+",2558,,,,,06-07-2018 13:51,,,,0,,,,CC BY-SA 4.0 +2258,1,2259,,06-07-2018 15:03,,17,7919,"I would like to simulate the 4 ""Bell States"" on the IBM composer?
+ +How can I best implement those 4 Bell states using the existing set of gates ?
+ +Here below you see the definition of the 4 Bell states.
+ +The first bell state can be easily implemented on the composer through a Hadamard gate and a CNOT gate as follows:
+ +but how can I implement the other 3 bell states ?
+",2529,,26,,12/13/2018 19:52,7/25/2021 0:14,How to implement the 4 Bell states on the IBM Q (composer)?,Remember that the Hadamard (H) gate maps $|0\rangle$ to $\frac{|0\rangle+|1\rangle}{\sqrt{2}}$ and $|1\rangle$ to $\frac{|0\rangle-|1\rangle}{\sqrt{2}}$, while the CNOT gate has the following conversion table:
+ +So, you can use the same circuit:
+ +but begin in the states $|01\rangle$, $|10\rangle$ and $|11\rangle$ to get the other three Bell states (you can easily convert to these states from $|00\rangle$ using the Pauli-X gate).
+ +Source: Todd Brun's lecture notes, Part-11
+",26,,26,,06-07-2018 16:06,06-07-2018 16:06,,,,0,,,,CC BY-SA 4.0 +2260,2,,2258,06-07-2018 15:34,,11,,"One of the possible solutions:
+$|\Phi^+\rangle = \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Phi^-\rangle = Z_1 |\Phi^+\rangle = Z_1 \cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Psi^+\rangle = X_2 |\Phi^+\rangle = X_2 \cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Psi^-\rangle = Z_1 |\Psi^+\rangle = Z_1 \cdot X_2 \cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
Where $Z_i$ and $X_i$ act on the $i^\textrm{th}$ qubit.
++
So here is $|\Phi^-\rangle$:
+Here is $|\Psi^+\rangle$:
+And here is $|\Psi^-\rangle$:
++
Another solution is:
+$|\Phi^+\rangle = \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Phi^-\rangle = X_1 \cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Psi^+\rangle = X_2 \cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
+$|\Psi^-\rangle = Z_1 X_2\cdot \textrm{CNOT} \cdot H_1 |00 \rangle$
I have just started to learn about quantum computing, and I know a little bit about qubits. What is a resource where I can learn a basic quantum algorithm and the concepts behind how it works?
+",2566,,2293,,06-12-2018 15:34,1/20/2022 11:24,Resources for quantum algorithm basics,Most textbooks and lecture courses start with solving the Deutsch problem using quantum computing.
+Parts 1 to 4 of John Watrous's lecture notes will describe the concepts, starting from basics. By the end of lecture 4, you will have learned how a quantum computer can solve the Deutsch problem with fewer operations than a classical computer would need.
+All 22 lecture notes can be found here.
+",2293,,14495,,1/15/2022 18:38,1/15/2022 18:38,,,,0,,,,CC BY-SA 4.0 +2263,1,,,06-07-2018 23:14,,42,23485,"The Bell state $|\Phi^{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle )$ is an entangled state. But why is that the case? How do I mathematically prove that?
+",,user72,,,,11-10-2022 01:08,How do I show that a two-qubit state is an entangled state?,user1271772's answer is entirely correct. I was going to comment with additional information to help answer nippon's question, but I just created this account and apparently there's a reputation requirement before adding comments.
+ +D-Wave's superconducting flux qubits are niobium metal loops that form a ""hash symbol"" made of two flat layers that have been stretched out and laid parallel. One layer is 90-degrees rotated from the other. When you move charge (current) in a loop it produces a magnetic field perpendicular to the plane of the loop. When you move a magnetic field through a charge-carrying loop it induces motion in the charge (current). But the amount of induction is partly determined by the size of the overlapping area (not linearly, since perfect overlap doesn't mean perfect induction, and non-overlapping adjacent wires still do it) so you can't currently usefully overlap 1000x1000 because the influence on each neighbor would be small. Stacking more layers is hard for the same reason wireless charging only just started to not suck.
+ +The D-Wave uses Niobium loops interspersed with these amazing little quantum-permeable membrane slices called Josephson Junctions (that won their discoverer a Nobel before he went a little wacky) cooled to just above 0 kelvin, so they can hold a charge with zero resistance. Basic quantum computing hardware generally has to be robust to decoherence, which means it can't interact much with the outside environment (should be its own Hamiltonian). There's already a ton of control hardware and stuff that has to go into keeping it all stable. Every time they move the machine they have to recalibrate it (at least with the DW2) and a new random arrangement of like 90% of the qubits will work until it's calibrated again. So it's actually a harder problem than just fitting to a chimera graph. Needs to be a readily radiation-hardenable system of some kind, e.g. a neural network.
+",2567,,2567,,06-09-2018 17:18,06-09-2018 17:18,,,,3,,,,CC BY-SA 4.0 +2266,2,,2263,06-08-2018 05:18,,30,,"A two qudit pure state is separable if and only if it can be written in the form $$|\Psi\rangle=|\psi\rangle|\phi\rangle$$ for arbitrary single qudit states $|\psi\rangle$ and $|\phi\rangle$. Otherwise, it is entangled.
+ +To determine if the pure state is entangled, one could try a brute force method of attempting to find satisfying states $|\psi\rangle$ and $|\phi\rangle$, as in this answer. This is inelegant, and hard work in the general case. A more straightforward way to prove whether this pure state is entangled is the calculate the reduced density matrix $\rho$ for one of the qudits, i.e. by tracing out the other. The state is separable if and only if $\rho$ has rank 1. Otherwise it is entangled. Mathematically, you can test the rank condition simply by evaluating $\text{Tr}(\rho^2)$. The original state is separable if and only if this value is 1. Otherwise the state is entangled.
+ +For example, imagine one has a pure separable state $|\Psi\rangle=|\psi\rangle|\phi\rangle$. The reduced density matrix on $A$ is +$$ +\rho_A=\text{Tr}_B(|\Psi\rangle\langle\Psi|)=|\psi\rangle\langle\psi|, +$$ +and +$$ +\text{Tr}(\rho_A^2)=\text{Tr}(|\psi\rangle\langle\psi|\cdot |\psi\rangle\langle\psi|)=\text{Tr}(|\psi\rangle\langle\psi|)=1. +$$ +Thus, we have a separable state.
+ +Meanwhile, if we take $|\Psi\rangle=\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$, then +$$ +\rho_A=\text{Tr}_B(|\Psi\rangle\langle\Psi|)=\frac12\left(|0\rangle\langle 0|+|1\rangle\langle 1|\right)=\frac12\mathbb{I} +$$ +and +$$ +\text{Tr}(\rho_A^2)=\frac14\text{Tr}(\mathbb{I}\cdot\mathbb{I})=\frac12 +$$ +Since this value is not 1, we have an entangled state.
+ +If you wish to know about detecting entanglement in mixed states (not pure states), this is less straightforward, but for two qubits there is a necessary and sufficient condition for separability: positivity under the partial transpose operation.
+",1837,,1867,,12/23/2018 14:54,12/23/2018 14:54,,,,3,,,,CC BY-SA 4.0 +2267,1,2274,,06-08-2018 09:03,,6,391,"I am looking for an implementation using the quantum gates provided by the IBM composer of the following quantum function:
+ +-
+
- input $2n$ qubits +
- output $2n$ qubits wherein $50\%$ of the cases the state of the $2$ sets of $n$ qubits are swapped and in the other $50\%$ of the cases the state of the $2n$ qubits remain unchanged. With swapped I mean that qubit $q[i]$ will get the state of qubit $q[n+i]$ and qubit $q[n+i]$ will get the state of $q[i]$. Note also that all the qubits must be swapped or not. +
E.g. $n=3$: If input $|000111\rangle$ then output in 50% of the cases is $|000111\rangle$ and in the other 50% of the cases is $|111000\rangle$
+ +We have already a solution when $n=1$ in the following StackOverflow question:
+ + + +but how can we do that when $n>1$?
+",2529,,26,,12/13/2018 19:52,12/13/2018 19:52,How to implement a Square root of Swap gate that swaps 2n-qubits on the IBM Q (composer)?,Let's say two qubits are both in $|+\rangle$ state. We need to find $a_1$, $a_2$, $a_3$, and $a_4$ in $|\phi\rangle = a_1|00\rangle + a_2|01\rangle + a_3|10\rangle + a_4|11\rangle$, how do we find these amplitudes? How do we do it in general case, when each of the qubits are not necessarily in $|+\rangle$ state, but in some $|?\rangle$ state?
+",2559,,26,,12/23/2018 12:30,12/23/2018 12:30,How to calculate the state given by two qubits?,Start by writing out what the $|+\rangle$ state actually is: +$$ +|+\rangle=\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) +$$ +So, two qubits in the state $|+\rangle$ are in the state +$$ +|+\rangle|+\rangle=\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)\otimes \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) +$$ +You then need to expand this out, making use of the distributivity of the tensor product, and match up with the specified form of $|\phi\rangle$. Since this sounds a bit like a homework problem, I'm not going to do that for you explicitly. (If you've tried something and got stuck, show us what you tried!)
+ +The general case is absolutely equivalent, you just replace $|+\rangle|+\rangle$ with something like +$$ +(b_0|0\rangle+b_1|1\rangle)\otimes (b_2|0\rangle+b_3|1\rangle) +$$
+",1837,,,,,06-08-2018 10:21,,,,3,,,,CC BY-SA 4.0 +2270,1,2271,,06-08-2018 12:29,,15,9687,"Let's say we have a circuit with $2$ Hadamard gates:
+ +Let's take the $|00\rangle$ state as input. The vector representation of $|00\rangle$ state is $[1 \ 0 \ 0 \ 0]$, but this is the representation of $2$ qubits and H accepts just $1$ qubit, so should we apply the first H gate to $[1 \ 0]$ and the second H gate to $[0 \ 0]$? Or should we input $[1 \ 0]$ in each H gate, because we are applying H gates to just one qubit of state $|0\rangle$ each time?
+",2559,,26,,12/23/2018 12:30,12/23/2018 12:30,How to input 2 qubits in 2 Hadamard gates?,++ +Or should we input $[1 \ 0]$ in each H gate, because we are applying H + gates to just qubit of state $|0\rangle$ each time?
+
Yes, when you have a two-qubit state (say you label the two qubits as $A$ and $B$ respectively), you need to apply the two Hadamard gates separately on each qubit's state. The final state will be the tensor product of the two ""transformed"" single-qubit states.
+ +If your input is $|0\rangle_A\otimes|0\rangle_B$, the output will simply be $$\left(\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right)_B$$
+ ++ +
Alternative:
+ +If the two input qubits are entangled, the above method won't work since you won't be able to represent the input state as a tensor product of the states of the two qubits. So, I'm outlining a more general method here.
+ +When two gates are in parallel, like in your case, you can consider the tensor product of the two gates and apply that on the 2-qubit state vector. You'll end up with the same result.
+ +$\frac{1}{\sqrt{2}}\begin{bmatrix}1&1\\1&-1\\ \end{bmatrix} \otimes \frac{1}{\sqrt{2}}\begin{bmatrix}1&1\\1&-1\\ \end{bmatrix} = \frac{1}{2}\begin{bmatrix}1&1&1&1\\1&-1&1&-1\\1&1&-1&-1\\1&-1&-1&1 \end{bmatrix}$
+ +Now, on applying this matrix on the 2-qubit state $\begin{bmatrix}1\\0\\0\\0\end{bmatrix}$ you get:
+ +$$\frac{1}{2}\begin{bmatrix}1&1&1&1\\1&-1&1&-1\\1&1&-1&-1\\1&-1&-1&1 \end{bmatrix} \begin{bmatrix}1\\0\\0\\0\end{bmatrix}=\begin{bmatrix}1/2\\1/2\\1/2\\1/2\end{bmatrix}$$
+ +which is equivalent to $$\left(\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle+|1\rangle}{\sqrt{2}}\right)_B$$
+ +Justification
+ +Tensor product of linear maps:
+ +++ +The tensor product also operates on linear maps between vector spaces. + Specifically, given two linear maps $S : V \to X$ and $T : W \to Y$ + between vector spaces, the tensor product of the two linear maps $S$ + and $T$ is a linear map $(S\otimes T)(v\otimes w) = S(v) \otimes T(w)$ + defined by $(S\otimes T)(v\otimes w) = S(v) \otimes T(w)$.
+
Thus, $$(\mathbf H|0\rangle_A) \otimes (\mathbf H|0\rangle_B) = (\mathbf H\otimes \mathbf H)(|0\rangle_A \otimes |0\rangle_B)$$
+",26,,26,,06-08-2018 13:51,06-08-2018 13:51,,,,0,,,,CC BY-SA 4.0 +2274,2,,2267,06-08-2018 17:16,,3,,"A general trick for smoothing a big discrete operation into a continuous operation is to apply the phase estimation algorithm, then apply a phase gradient to the phase register, then uncompute the phase estimation. For example, see this blog post on computing the fractional fourier transform.
+ +Because the swap operation has exactly two eigenvalues (+1 and -1), the phase estimation is extremely simple. It only requires a single phase estimation qubit. The resulting circuit looks like this:
+ +Note that the top qubit should start and end in the 0 state. You can continuously vary how much swappery there is by varying the angle of the Z rotation in the middle.
+",119,,119,,06-08-2018 23:00,06-08-2018 23:00,,,,2,,,,CC BY-SA 4.0 +2275,1,,,06-09-2018 10:00,,7,410,"Suppose we have a qutrit with the state vector $|\psi\rangle = a_0|0\rangle + a_1|1\rangle + a_2|2\rangle$, and we want to project its state onto the subspace having the basis $\{|0\rangle,|2\rangle\}$, I know the projection operator would be written like: $1|0\rangle \langle0| + 0|1\rangle\langle 1| + 1|2\rangle\langle2|$.
+ +I'm having a few confusions here. Does $|0\rangle \langle 0|$ represent a tensor product between $[1 \ 0 \ 0]^{T}$ and $[1 \ 0 \ 0]$ ? Or is it just matrix multiplication? Also, I thought that we must always be able to write a projection operator in the form $|\phi\rangle \langle \phi|$ where $|\phi\rangle$ is a possible state of a qutrit. But how to represent $1|0\rangle \langle0| + 0|1\rangle\langle 1| + 1|2\rangle\langle2|$ in the form $|\phi\rangle \langle \phi|$?
+",2582,,26,,06-09-2018 11:27,06-12-2018 06:52,Confusion regarding projection operator,Let's say we have the following quantum circuit:
+ +Let's say we input the state $|00\rangle$ . Both of the $H$ gates produce the output $1/\sqrt{2}$, but which one of the following $2$ vectors is the input of $\operatorname{CNOT}$ gate: +$1: [1/\sqrt{2}, \ 1/\sqrt{2}, \ 1/\sqrt{2}, \ 1/\sqrt{2}]$ or +$2: [1/2, \ 1/2, \ 1/2, \ 1/2]$? +Also, after applying a $2$ qubit gate (in this case $\operatorname{CNOT}$) how do we find out what to input in the following single qubit gates (in this case two $H$ gates)? +Note that I gave this example for simplicity, a general answer will also be accepted.
+",2559,,26,,12/23/2018 12:31,12/23/2018 12:31,How to apply single and two qubit gates to 2 qubits multiple times?,Step 1 (application of two hadamard gates):
+ +$$|0\rangle_A \otimes |0\rangle_B \to \left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_B$$
+ +This is equivalent to the state vector: $\begin{bmatrix}1/2\\1/2\\1/2\\1/2\end{bmatrix}$, which will act as the input for your CNOT gate.
+ +Step 2: (application of CNOT)
+ +Let's remind ourselves what the CNOT gate does:
+ +So clearly, +$$\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_B = \frac{1}{2}(|00\rangle + |01\rangle + |10\rangle + |11\rangle)$$ $$\to \frac{1}{2}(|00\rangle + |01\rangle + |11\rangle + |10\rangle) = \left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_B$$
+ +Step 3: (re-application of two Hadamard gates)
+ +$$\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_A\otimes\left(\frac{|0\rangle + |1\rangle}{\sqrt{2}}\right)_B \to |0\rangle_A \otimes |0\rangle_B$$
+ +Here, we used that fact that the Hadamard gate maps the state $\dfrac{|0\rangle + |1\rangle}{\sqrt{2}}$ to the state $|0\rangle$, for each qubit. You basically need to input the vector $\begin{bmatrix}1/\sqrt{2}\\1/\sqrt{2}\end{bmatrix}$ into the two Hadamard gates at the end. Find the state transformation on each qubit. From there you can construct the state vector for the final 2-qubit state. The final answer will be $\begin{bmatrix}1 \\ 0 \\ 0 \\ 0\end{bmatrix}$. Clearly, we end up with the same 2-qubit state which we started with.
+ +Exercise: Carry out steps $2$ and $3$ using the matrix notation. Also, check this related answer.
+",26,,26,,06-09-2018 13:25,06-09-2018 13:25,,,,0,,,,CC BY-SA 4.0 +2278,1,2279,,06-09-2018 13:27,,6,475,"My idea was to apply $Z$ operator 𝐭𝐰𝐢𝐜𝐞, which leads us back to the point where we started from, and also show that after applying the $Z$ operator just 𝐨𝐧𝐜𝐞 we are not at the same point where we started (this is for showing that we are not rotating by a multiple of $360^{\circ}$). Is this the correct proof? What about the general case, where we want to find out through how many degrees a given operator rotates the points?
+",2559,,26,,06-09-2018 13:54,06-09-2018 14:52,How to prove that Z operator rotates points on Bloch sphere about Z axis through 180°?,The Pauli-$Z$ gate maps $|0\rangle$ to $|0\rangle$ and $|1\rangle$ to $-|1\rangle$.
+For Bloch sphere representation, state of a qubit is written like (look at my previous answer for a detailed explanation)
+$$|\psi\rangle = \cos(\theta/2)|0\rangle + e^{i\phi}\sin(\theta/2)|1\rangle$$
+Apply the Pauli-$Z$ gate on this and you get:
+$$|\psi'\rangle = \cos(\theta/2)|0\rangle + (-1)e^{i\phi}\sin(\theta/2)|1\rangle$$
+$$=\cos(\theta/2)|0\rangle + e^{i(\phi+\pi)}\sin(\theta/2)|1\rangle$$
+Thus, the angle $\phi$ changes by $\pi$. We can call $\phi + \pi$ as $\phi'$ now.
+Remind yourself what the Bloch sphere looks like:
+Clearly, from the diagram, if the angle $\phi$ is changed by $\pi$, it will imply that the state of the qubit has been rotated about the Z-axis by $180$ degrees.
+",26,,-1,,6/18/2020 8:31,06-09-2018 13:45,,,,0,,,,CC BY-SA 4.0 +2280,2,,2275,06-09-2018 14:21,,8,,"++ +Does $|0\rangle\langle0|$ represent a tensor product or is it just matrix multiplication?
+
You can think of $|0\rangle\langle0|$ as tensor product of $|0\rangle$ and $\langle0|$, or equivalently as the matrix multiplication (more precisely, Kronecker product) of the vectors representing them.
+ +++ +Also, I thought that we must always be able to write a projection operator in the form |ϕ⟩⟨ϕ|
+
Not necessarily. +A projector will have that form if and only if it projects onto a one-dimensional space (that is, it projects onto a pure state). +More general projections, like the one you mention, do not have this feature, and that is totally fine.
+ +Indeed, also the identity matrix is a (trivial) projection, and it certainly cannot be written as $|\psi\rangle\langle\psi|$ for any pure state $|\psi\rangle$.
+",55,,,,,06-09-2018 14:21,,,,1,,,,CC BY-SA 4.0 +2281,2,,2278,06-09-2018 14:52,,2,,"One can more generally show that $R_z(\theta)=e^{-i \theta Z/2}=\cos(\theta/2)-iZ\sin(\theta/2)$ rotates points on the Bloch sphere by an angle $\theta$ around the $z$-axis, +and note that $Z=i R_z(\pi)$.
+ +Let $|\psi\rangle$ be an arbitrary pure state. The coordinates of the point representing $|\psi(\theta)\rangle\equiv R_z(\theta)|\psi\rangle$ on the Bloch sphere are +$$x(\theta)=\langle\psi(\theta)|X|\psi(\theta)\rangle, \\ y(\psi)=\langle\psi(\theta)|Y|\psi(\theta)\rangle, \\ +z(\psi)=\langle\psi(\theta)|Z|\psi(\theta)\rangle.$$ +That this point follows a circular trajectory around the $z$-axis when $\theta$ goes from $0$ to $2\pi$, +can be seen by direct calculation as follows:
+ +\begin{align} +x(\theta) &=\langle\psi\rvert R_z(-\theta)\,X\,R_z(\theta)\lvert\psi\rangle = +\cos\theta\,x(0) + \sin\theta\,y(0), \\ +y(\theta) &=\langle\psi\rvert R_z(-\theta)\,Y\,R_z(\theta)\lvert\psi\rangle = +-\sin\theta\,x(0) + \cos\theta\,y(0), \\ +z(\theta) &= z(0). +\end{align}
+ +Note that the same is true more generally for mixed states: the point representing $\rho(\theta)\equiv R_z(\theta)\rho R_z(\theta)^\dagger$ in the Bloch sphere is +$$\newcommand{\Tr}{\operatorname{Tr}} +x(\theta)=\Tr(X\rho(\theta)), \\ +y(\theta)=\Tr(Y\rho(\theta)), \\ +z(\theta)=\Tr(Z\rho(\theta)),$$ +and one can show by direct calculation that this point evolves similarly to the pure case.
+",55,,,,,06-09-2018 14:52,,,,0,,,,CC BY-SA 4.0 +2282,1,2285,,06-10-2018 12:34,,43,7223,"Is it because we don't know exactly how to create quantum computers (and how they must work), or do we know how to create it in theory, but don't have the tools to execute it in practice? Is it a mix of the above two? Any other reasons?
+",2559,,-1,,10/17/2022 0:09,10/17/2022 0:09,Why is it harder to build quantum computers than classical computers?,During a description of zero-dimensional self-dual $\text{GF}(4)$ quantum codes in ""On self-dual quantum codes, graphs, and Boolean functions"" by L.E. Danielsen, it states:
+ +++ +A zero-dimensional stabilizer code with high distance represents a single quantum state which is robust to error, sometimes called a stabilizer state. Codes of higher dimension can be constructed from zero-dimensional quantum codes...
+
My question has two parts:
+ +Firstly, I am confused by what is meant here by a ""single quantum state"". To my understanding, the passage seems to confuse the encoded 0-dimensional qubit state (which is robust to Pauli error), i.e. a single ""qubit"" state, with the single ""stabilizer"" state which is represented by the generators of the code (which is not robust to error, as a single Hadamard on any qubit would be sufficient to take it to a completely different stabilizer state). Is this the case, or am I misunderstanding something here?
+ +Secondly, what form do these constructions take in practice? Is this simply achieved by not enforcing one of the stabilizer's generators, or are there other more general methods? Furthermore, if there are multiple construction methods, what are their advantages or disadvantages (both in the codes they create and/or the complexity of the construction)?
+",391,,391,,06-11-2018 06:47,06-11-2018 08:45,Zero-distance self-dual GF(4) quantum codes and constructing k > 0 codes from them,I know that 2 qubits are entangled if it is impossible to represent their joint state as a tensor product. But when we are given a joint state, how can we tell if it is possible to represent it as a tensor product? +For example, I am asked to tell if the qubits are entangled for each of the following situations:
+ +$$\begin{align} +\left| 01 \right>\\ +\frac 12(\left| 00 \right> + i\left| 01 \right> - i\left| 10 \right> + i\left| 11 \right> )\\ +\frac 12(\left| 00 \right> - \left| 11 \right>)\\ +\frac 12(\left| 00 \right> + \left| 01 \right> +i\left| 10 \right> + \left| 11 \right> ) \end{align}$$
+",2559,,26,,12/23/2018 12:31,12/23/2018 12:31,How to check if 2 qubits are entangled?,We know exactly, in theory, how to construct a quantum computer. But that is intrinsically more difficult than to construct a classical computer.
+ +In a classical computer, you do not have to use a single particle to encode bits. Instead, you might say that anything less than a billion electrons is a 0 and anything more than that is a 1, and aim for, say, two billion of electrons to encode a 1 normally. That makes you inherently fault-tolerant: Even if there are hundreds of millions of electrons more or less than expected, you will still get the correct classification as a digital 0 or a 1.
+ +In a quantum computer, this trick is not possible due to the non-cloning theorem: You cannot trivially employ more than one particle to encode a qubit (quantum bit). Instead, you must make all your gates operate so well that they are not just accurate to the single particle level but even to a tiny fraction of how much they act on a single particle (to the so-called quantum-error correction threshold). This is much more challenging than to get gates accurate merely to within hundreds of millions of electrons.
+ +Meanwhile we do have the tools to, just barely, make quantum computers with the required level of accuracy. But nobody has, as of yet, managed to make a big one meaning one that can accurately operate on the perhaps hundred of thousands of physical qubits needed to implement a hundred or so logical qubits to then be undeniably in the realm where the quantum computer beats classical computers at select problems (quantum supremacy).
+",,user1039,,user1039,06-10-2018 19:00,06-10-2018 19:00,,,,4,,,,CC BY-SA 4.0 +2286,2,,2284,06-10-2018 18:12,,3,,"It is done for a specific state (a Bell state) here, and the same procedure can be used for any other two-qubit state.
+",2293,,2293,,7/13/2018 14:47,7/13/2018 14:47,,,,0,,,,CC BY-SA 4.0 +2287,2,,2284,06-10-2018 18:13,,4,,"If you are given a general 2-qubit state $a \mid 00 \rangle + b \mid 01 \rangle + c \mid 10 \rangle + d \mid 11 \rangle$
+ +If it is unentangled, then the coefficients are that of $(\alpha \mid 0 \rangle + \beta \mid 1 \rangle)(\gamma\mid 0 \rangle + \delta \mid 1 \rangle)$ for some $\alpha .. \delta$.
+ +$$ +\alpha \gamma = a\\ +\alpha \delta = b\\ +\beta \gamma = c\\ +\beta \delta = d +$$
+ +You want to know if those 4 equations are solvable for a given $a,b,c,d$. This question becomes
+ +$$ +ad - bc = 0 +$$
+ +so if $ad-bc=0$, then you can solve for $\alpha .. \delta$. You don't need to solve for them, you just need to need to know if it is possible.
+ +The generalization for qudits with potentially different values of $d_1$ and $d_2$ are the quadratic polynomials that cut out the Segre embedding as a zero locus.
+",434,,,,,06-10-2018 18:13,,,,2,,,,CC BY-SA 4.0 +2288,2,,2282,06-10-2018 22:04,,11,,"There's many reasons, both in theory and implementation, that make quantum computers much harder to build.
+ +The simplest might be this: while it is easy to build machines that exhibit classical behaviour, demonstrations of quantum behaviour require really cold and really precisely controlled machines. The thermodynamic conditions of the quantum regime are just hard to access. When we finally do achieve a quantum system, it's hard to keep it isolated from the environment which seeks to decohere it and make it classical again.
+ +Scalability is a big issue. The bigger our computer, the harder it is to keep quantum. The phenomena that promise to make quantum computers really powerful, like entanglement, require the qubits can interact with eachother in a controlled way. Architectures that allow this control are hard to engineer, and hard to scale. Nobody's agreed on a design!
+ +As @pyramids points out, the strategies we use to correct errors in classical machines usually involve cloning information, which is forbidden by quantum information theory. While we have some strategies to mitigate errors in clever quantum ways, they require that are qubits are already pretty noise-free and that we have lots of them. If we can't improve our engineering past some threshold, we can't employ these strategies - they make things worse!
+",2591,,,,,06-10-2018 22:04,,,,1,,,,CC BY-SA 4.0 +2289,1,,,06-10-2018 23:24,,5,99,"I've accidentally written a procedure which appears to compute both outputs of a long-running function $f: \{0,1\} \to \{1...n\}$ using one run of $f$ plus $\mathcal{O}(n)$ time. I thought this couldn't be done. Where's the bug in my ""perpetuum mobile""? If I'm wrong, what's the name of this technique?
+ +-
+
Initialize with $\sum_ic_i|i\rangle_x$, with $c_0$ initially, say, $\sqrt½$, and the invariant $\sum_ic_i^2 = 1$.
+Compute $f(x)$, producing: $\sum_ic_i|i\rangle_x|f_i\rangle$ (1). We never evaluate $f$ again, and our goal is to extract these $f_i$.
+Produce: +$$ +\sqrt½\sum_ic_i|i\rangle_x|f_i\rangle(|i^{|a|}\rangle_a|f_i\rangle_b+2^{-|a+b|/2}\sum_{rs}|r\rangle_a|s\rangle_b) +$$
+Measure and discard the $a$ and $b$ registers, getting (1) with $c_0^2 \in \{1/(2+2^{|a|+|b|}), ½, 1-1/(2+2^{|a|+|b|})\}$, and in all probability we know which.
+Use amplitude amplification, where the good and bad subspaces are distinguished using the $x$ qubit, to get $c_0^2$ between ⅛ and ⅞.
+Repeat the last 3 *s a bunch of times.
+In all probability, we've measured $f_0$ and $f_1$.
+
I have to disagree with the idea that the no-cloning theorem makes error correction with repetition codes difficult. Given that your inputs are provided in the computational basis (i.e. you inputs are not arbitrary superpositions, which is almost always the case, especially when you're solving a classical problem e.g. Schor's algorithm), you can clone them with controlled-Not gates, run your computation in parallel on all the copies, and then correct errors. The only trick is to make sure you don't do a measurement during error-correction (except possibly of the syndrome), and to do this all you have to do is continue to make use quantum gates.
+Error correction for quantum computers is not much more difficult than for classical computers. Linearity takes can of most of the perceived difficulties.
+I'd also like to mention that there are much more efficient schemes for quantum error correction than repetition codes. And that you need two pauli-matrices to generate the rest, so you need two types of repetition codes if you're going to go for the inefficient, but conceptually simple repetition code route (one for bit-flips and one for phase flips).
+Quantum error correction shows that linear increase in the number of physical qubits per logical qubit improves the error rate exponentially, just as it does in the classical case.
+Still, we're nowhere near 100 physical qubits. This is the real problem. We need to be able to glue a lot more semi-accurate qubits together before any of this starts to matter.
+",2595,,2595,,09-08-2020 20:00,09-08-2020 20:00,,,,2,,,,CC BY-SA 4.0 +2291,2,,2289,06-11-2018 06:56,,1,,"There's quite a lot that doesn't make sense in your described protocol, at least to me! It would be a lot clearer in terms of bras and kets. Let me try to translate, and you can comment to try and get us one the same page...
+ +-
+
Let $|x\rangle=(|0\rangle+|1\rangle)/\sqrt{2}$
+Compute $f(x)$, so you have $(|0\rangle|f(0)\rangle+|1\rangle|f(1)\rangle)/\sqrt{2}$
+Let $|m\rangle=(|0\rangle+|1\rangle)/\sqrt{2}$, so that we have an overall state +$$ +(|0\rangle_m|000\ldots 0\rangle_a|f(0)\rangle_b+|1\rangle_m|111\ldots 1\rangle_a|f(1)\rangle_b)/\sqrt{2} +$$
+Measure the $a$ and $b$ registers.
+
What I don't understand: you've defined $|x\rangle$ but never used it. You've initialised the registers $a$ and $b$, but overwritten them immediately (so why did you initialise them?). What amplitude is it that you think you want to amplify?
+ +With 50:50 probability, you either get $|0\rangle_m|000\ldots 0\rangle_a|f(0)\rangle_b$ or $|1\rangle_m|111\ldots 1\rangle_a|f(1)\rangle_b$. So, to get both values, you repeat until you've got both values. That requires a few runs. At best it takes 2, but you'd be better off just evaluating $f(0)$ and $f(1)$ by using two runs.
+ ++ +
Update after question revision:
+ +There are still issues with the description of the protocol: what is $d$, and how do you produce such a state with $d\neq0$? Surely you're better off just leaving $d=0$?
+ +However, i think we're now getting to the point of main misunderstanding, which is counting the circuit complexity. Every time you produce the state +$$ +|\Psi_f\rangle=\sqrt½\sum_ic_i|i\rangle_x|f(i)\rangle(|i^{|a|}\rangle_a|f(i)\rangle_b+d\sum_{rs}|r\rangle_a|s\rangle_b) +$$ +you have to evaluate the function $f(x)$. If that is the costly function to evaluate, you have to count the number of repetitions. You say ""Repeat the last 3 *s a bunch of times."", so that costs you a bunch of function evaluations, while just evaluating $f(0)$ and $f(1)$ costs you exactly 2 function evaluations. Moreover, to get 2 answers out, you must repeat your procedure at least twice, so you can never even get lucky and beat the naive classical case sometimes.
+ +Note that if you want to be able to copy the state $|\Psi_f\rangle$, then for all different functions $f(x)$, those states must be orthogonal. However, consider two different functions: $f(0)=f(1)=0$ and $g(0)=0,g(1)=1$. We have that $\langle\Psi_f|\Psi_g\rangle\neq 0$.
+",1837,,1837,,06-11-2018 09:28,06-11-2018 09:28,,,,7,,,,CC BY-SA 4.0 +2292,1,2374,,06-11-2018 07:07,,14,660,"There are many fairly standard quantum algorithms that can all be understood within a very similar framework, from Deutsch's algorithm Simon's problem, Grover's search, Shor's algorithm and so on.
+ +One algorithm that seems to be completely different is the algorithm for evaluating the Jones Polynomial. Moreover, it seems like this is a crucial algorithm to understand in the sense that it is a BQP-complete problem: it exhibits the full power of a quantum computer. Also, for a variant of the problem, it's DQC-1 complete, i.e. it exhibits the full power of one clean qubit.
+ +The Jones Polynomial algorithm paper presents the algorithm in a very different way to the other quantum algorithms. Is there a more similar/familiar way that I can understand the algorithm (specifically, the unitary $U$ in the DQC-1 variant, or just the whole circuit in the BQP-complete variant)?
+",1837,,1837,,6/15/2018 13:26,6/17/2018 23:52,Jones Polynomial,For the first part of the question, I think that with ""single quantum state"", the author is referring to the encoded quantum state, which will be an state formed by $n$-qubits. Such state is called stabilizer state because the encoding operation takes the input state, in this case $|0\rangle^{\otimes n}$, and takes it to a state in the codespace defined by the stabilizers. This code space is defined to be the $+1$ simultaneous eigenspace of the stabilizer operators, and in general has dimension $2^k$, so as in this case $k=0$, the dimension of this codespace will be $1$. Consequently, the author is trying to state that such zero-dimensional stabilizer codes refer to the basis of such $1$ dimensional subspace, which will be just a single quantum state.
+ +Also the author says that such state is robust to errors because an stabilizer error correction code is being applied to the state, and so errors will be correctable. Obviously a Hadamard gate would change the encoded state, but I think that with robust, the author is trying to say that the state can be corrected after the appearance of Pauli errors, that is $\{X,Y,Z\}^{\otimes n}$ operators applied to the state. This robustness obviously comes from the fact that an error-correction code is being applied to the $n$-ancilla qubit input state.
+ +Then this codes would be obtainded by finding such encoding operator that would take the input $n$-state to the $+1$ simultaneous eigenspace that the $n$ stabilizer generators define (Note that in general ${n-k}$ generators are needed and that here $k=0$). I don't know what do you exactly want to say with the frase ""enforcing one of the stabilizer's generators"". To find out the encoder unitary, most of the times, combinations of so-called Clifford gates are used, there are differents methods and algorithms in literature that are useful for finding the exact combination.
+",2371,,2371,,06-11-2018 08:45,06-11-2018 08:45,,,,2,,,,CC BY-SA 4.0 +2294,2,,2282,06-11-2018 08:33,,3,,"One important point is that quantum computers contain classical computers. So it must be at least as hard to build a quantum computer as it is a classical computer.
+ +For a concrete illustration, it's worth thinking about universal gate sets. In classical computation, you can create any circuit you want via the combination of just a single type of gate. Often people talk about the NAND gate, but for the sake of this argument, it's easier to talk about the Toffoli gate (also known as the controlled-controlled-not gate). Every classical (reversible) circuit can be written in terms of a whole bunch of Toffolis. An arbitrary quantum computation can be written as a combination of two different types of gate: the Toffoli and the Hadamard.
+ +This has immediate consequences. Obviously, if you're asking for two different things, one of which does not exist in classical physics, that must be harder than just making the one thing that does exist in classical physics. Moreover, making use of the Hadamard means that the sets of possible states you have to consider are no longer orthogonal, so you cannot simply look at the state and determine how to proceed. This is particularly relevant to the Toffoli, because it becomes harder to implement as a result: before, you could safely measure the different inputs and, dependent upon their values, do something to the output. But if the inputs are not orthogonal (or even if they are, but in an unknown basis!) you cannot risk measuring them because you will destroy the states, specifically, you destroy the superpositions that are the whole thing that's making quantum computation different from classical computation.
+",1837,,,,,06-11-2018 08:33,,,,2,,,,CC BY-SA 4.0 +2295,1,2325,,06-11-2018 08:34,,8,127,"In On the classification of all self-dual additive codes over $\textrm{GF}(4)$ of length up to 12 by Danielsen and Parker, they state:
+ +++ +Two self-dual additive codes over $\textrm{GF}(4)$, $C$ and $C^\prime$, are equivalent if and only if the codewords of $C$ can be mapped onto the codewords of $C^\prime$ by a map that preserves self-duality. Such a map must consist of a permutation of coordinates (columns of the generator matrix), followed by multiplication of coordinates by nonzero elements from $\textrm{GF}(4)$, followed by possible conjugation of coordinates.
+
with the previous definition
+ +++ +Conjugation of $x \in \textrm{GF}(4)$ is defined by $\bar{x} = x^2$.
+
I am confused what ""conjugation of coordinates"" means in this context. To me ""coordinates"" would normally refers to the code matrix's columns, or equivalently the quantum code's qubits. However, here it seems to be referring to the alphabet of the code, or equivalently the Pauli operators of the code's stabilizer generators. If this is the case, what operation does ""conjugation of coordinates"" represent with respect to the code's stabilizer generators?
+",391,,,,,6/13/2018 9:19,"What does ""conjugation of coordinates"" mean with respect to GF(4) (quantum) codes",I came across with a problem that involves $2$ quantum trits in state $\left| 22 \right>.$ What is it's tensor product interpretation and a matrix interpretation?
+",2559,,26,,12/23/2018 12:31,12/23/2018 12:31,What is the $\left| 22\right>$ state?,It is worth emphasising that the stuff that you write inside a ket is completely arbitrary. It's just a label you're attaching to something, so it should have a proper definition somewhere. Now, usually, we're talking about quantum spins with a certain size of Hilbert space, say $d$. Probably here you're talking $d\geq 3$, and perhaps specifically $d=3$. Then, one set of basis states is often written as $|i\rangle$ for $i=0,1,\ldots d-1$. You can choose to represent these as vectors $(0,0,\ldots,0,1,0,0,\ldots 0)$ where the 1 is the $i+1$th entry, and there are $d$ entries. So, I guess you're talking about +$$ +|2\rangle\equiv\left(\begin{array}{c} 0 \\ 0 \\ 1 \end{array}\right) +$$ +The tensor product $|2\rangle\otimes|2\rangle$ then has the standard meaning.
+",1837,,,,,06-11-2018 10:49,,,,0,,,,CC BY-SA 4.0 +2298,1,,,06-11-2018 11:18,,6,179,"One of the main ideas introduced in Giovannetti et al. 2007 +(0708.1879) is the so-called bucket-brigade (q)RAM architecture.
+ +The authors state (first paragraph, second column, first page, in v2) that this new (at the time) (q)RAM architecture reduces the number of switches that must be thrown during a RAM call, quantum or classical, from $O(N^{1/d})$ to $O(\log N)$, where $N=2^n$ is the number of memory slots in the RAM and $d$ is the dimension of the lattice that, according to the authors, conventional RAM architectures use for memory retrieval.
+ +The conventional architecture they have in mind essentially consists in retrieving the information using a tree structure, like the one they present in their Fig. 1 (here reproduced):
+ +They say that this scheme requires to throw $O(N)$ switches for each memory call, but I don't understand why is this the case. +From the above, it would seem that one just needs to throw $O(\log_2(N))$ +switches, one per bifurcation, to get from the top to the bottom.
+ +I understand that in the quantum case, with this protocol, we would end up with a state correlated with all of the $N$ switches, but they seem to be stating that even in the classical case one needs to activate them all.
+ +In other words, is the advantage of the bucket-brigade approach only in the higher error resilience in the quantum case, or would it also be classically advantageous, compared with the conventional approaches?
+",55,,55,,06-11-2018 11:35,6/18/2018 13:26,Are bucket-brigate (q)RAM architectures also advantageous in the classical case?,If a circuit takes more than one qubit as its input and has quantum gates which take different numbers of qubits as their input, how would we interpret this circuit as a matrix?
+ +Here is a toy example:
+ +Specific Circuit
+The first gate is a Hadamard gate which is normally represented by $$\frac{1}{\sqrt{2}}\begin{bmatrix}1&1\\1&-1\end{bmatrix}$$
+Now, since we're only applying it to the first qubit, we use a kronecker product on it (this confused me so much when I was starting out - I had no idea how to scale gates; as you can imagine, it's rather important), so we do $H\otimes I$, where $I$ is the 2x2 identity matrix. This produces
+$$\frac{1}{\sqrt{2}}\begin{bmatrix}1 & 0 & 1 & 0\\0 & 1 & 0 & 1\\ 1 & 0 & -1 & 0 \\ 0 & 1 & 0 & -1\end{bmatrix}$$
+Next we have a CNOT gate. This is normally represented by
+$$\begin{bmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{bmatrix}$$
+This is the right size for two qubits, so we don't need to scale using kronecker products. We then have another hadamard gate, which scales the same was as the first. To find the overall matrix for the circuit, then, we multiply them all together:
+$$\frac{1}{\sqrt{2}}\begin{bmatrix}1 & 0 & 1 & 0\\0 & 1 & 0 & 1\\ 1 & 0 & -1 & 0 \\ 0 & 1 & 0 & -1\end{bmatrix}\begin{bmatrix}1&0&0&0\\0&1&0&0\\0&0&0&1\\0&0&1&0\end{bmatrix}\frac{1}{\sqrt{2}}\begin{bmatrix}1 & 0 & 1 & 0\\0 & 1 & 0 & 1\\ 1 & 0 & -1 & 0 \\ 0 & 1 & 0 & -1\end{bmatrix}$$
+and get
+$$\frac{1}{2}\begin{bmatrix}1&1&1&-1\\1&1&-1&1\\1&-1&1&1\\-1&1&1&1\end{bmatrix}$$
+(if python multiplied correctly =) We would then multiply this by our original qubit state, and get our result.
+Generalization
+So basically, you go through each gate one by one, take the base representation, and scale them appropriately using kronecker products with identity matrices. Then you multiply all the matrices together in the order they are applied. Be sure to do this such that if you wrote out the multiplication, the very first gate is on the far right; as arriopolis points out, this is a common mistake. Matrices are not commutative! If you don't know the base representation of a matrix, check first wikipedia's article on quantum gates which has a lot.
+",91,,-1,,6/18/2020 8:31,06-12-2018 13:22,,,,4,,,,CC BY-SA 4.0 +2301,2,,2289,06-11-2018 13:51,,0,,"Ampltiude amplification seems to require both that it is easy to judge between good and bad (which is easy enough if one goes by the $x$ qubit), and that it is easy to get to one's starting point, which in this case requires evaluating $f$.
+",2592,,,,,06-11-2018 13:51,,,,0,,,,CC BY-SA 4.0 +2302,1,2304,,06-11-2018 15:16,,8,3278,"What does it mean to measure a qubit (or multiple qubits) in standard basis?
+",2559,,26,,12/23/2018 12:32,12/23/2018 12:32,Measuring in standard basis meaning,You define the projectors +$$ +P_0=|0\rangle\langle 0|=\left(\begin{array}{cc} 1 & 0 \\ 0 & 0 \end{array}\right)\qquad P_1=|1\rangle\langle 1|=\left(\begin{array}{cc} 0 & 0 \\ 0 & 1 \end{array}\right). +$$ +For any state $|\psi\rangle$, the probability of getting answer $x$ is $p_x=\langle\psi|P_x|\psi\rangle$ and, after the measurement, the qubit is in the state $|x\rangle$.
+ +If you want to measure multiple (say $n$) qubits in the standard basis, you can take arbitrary tensor products of the single-qubit terms, +$$ +P_x=|x\rangle\langle x|=\bigotimes_{i=1}^nP_{x_i} +$$ +for $x\in\{0,1\}^n$.
+ +Where you have to be a little more careful is if you're measuring only a subset of qubits. Then, the probability is still $p_x=\langle\psi|P_x|\psi\rangle$, but the output state is $P_x|\psi\rangle/\sqrt{p_x}$, which could still be a superposition of multiple basis states (all those for which the measured qubits correspond to $x$).
+",1837,,,,,06-11-2018 15:19,,,,0,,,,CC BY-SA 4.0 +2304,2,,2302,06-11-2018 15:45,,9,,"A $1$-qubit system, in general, can be in a state $a|0\rangle+b|1\rangle$ where $|0\rangle$ and $|1\rangle$ are basis vectors of a two dimensional complex vector space. The standard basis for measurement here is $\{|0\rangle,|1\rangle\}$. When you are measuring in this basis, with $\frac{|a|^2}{|a|^2+|b|^2}\times 100\%$ probability you will find that the state after measurement is $|0\rangle$ and with $\frac{|b|^2}{|a|^2+|b|^2}\times 100\%$ you'll find that the state after measurement is $|1\rangle$.
+ +But you could carry out the measurement in some other basis too, say $\{\frac{|0\rangle+|1\rangle}{\sqrt{2}},\frac{|0\rangle-|1\rangle}{\sqrt{2}}\}$, but that wouldn't be the standard basis.
+ +++ +Exercise: Express $a|0\rangle+b|1\rangle$ in the form $c(\frac{|0\rangle+|1\rangle}{\sqrt{2}})+d(\frac{|0\rangle-|1\rangle}{\sqrt{2}})$ + where $a,b,c,d\in\Bbb C$.
+
If you measure in the basis the probability of ending in the state $\frac{|0\rangle+|1\rangle}{\sqrt{2}}$ after a measurement is $\frac{|c|^2}{|c|^2+|d|^2}\times 100\%$ and probability of ending in the state $\frac{|0\rangle-|1\rangle}{\sqrt{2}}$ is $\frac{|d|^2}{|c|^2+|d|^2}\times 100\%$.
+ +Similarly, for a $2$-qubit system the standard basis would $\{|00\rangle,|01\rangle,|10\rangle,|11\rangle\}$ and its general state can be expressed as $\alpha|00\rangle + \beta|01\rangle + \gamma|10\rangle + \delta|11\rangle$. When you measure this in the standard basis you can easily see that the probability of ending up in the state (say) $|00\rangle$ will be $\frac{|\alpha|^2}{|\alpha|^2+|\beta|^2+|\gamma|^2+|\delta|^2}\times 100\%$. Similarly you can deduce the probabilities for the other states.
+ +You should be able to extrapolate this same logic to general $n$-qubit states, now. Feel free to ask questions in the comments.
+",26,,26,,06-11-2018 16:06,06-11-2018 16:06,,,,0,,,,CC BY-SA 4.0 +2305,2,,2292,06-11-2018 17:09,,4,,"You have mentioned five papers in the question, but one paper that remains unmentioned is the experimental implementation in 2009. Here you will find the actual circuit that was used to evaluate a Jones polynomial:
+ +This might be the closest you will get to a ""more familiar"" presentation of the algorithm, as interest in the Jones polynomial and in DQC-1 have decayed a bit since 2009.
+ +More details on this experiment can be found in Gina Passante's thesis.
+",2293,,2293,,6/14/2018 20:00,6/14/2018 20:00,,,,2,,,,CC BY-SA 4.0 +2306,1,2307,,06-11-2018 20:18,,10,611,"Here the authors argue that the efforts of creating a scalable quantum neural network using a set of parameterized gates are deemed to fail for a large number of qubits. This is due to the fact that, due to the Levy's Lemma, the gradient of a function in high dimensional spaces is almost zero everywhere.
+ +I was wondering if this argument can be also applied to other hybrid quantum-classical optimization methods, like VQE (Variational Quantum Eigensolver) or QAOA (Quantum Approximate Optimization Algorithm).
+ +What do you think?
+",1644,,55,,08-01-2020 11:37,08-01-2020 11:37,Barren plateaus in quantum neural network training landscapes,First: The paper references [37] for Levy's Lemma, but you will find no mention of ""Levy's Lemma"" in [37]. You will find it called ""Levy's Inequality"", which is called Levy's Lemma in this, which is not cited in the paper you mention.
+ +Second: There is an easy proof that this claim is false for VQE. In quantum chemistry we optimize the parameters of a wavefunction ansatz $|\Psi(\vec{p})\rangle$ in order to get the lowest (i.e. most accurate) energy. The energy is evaluated by:
+ +$$ +E_{\vec{p}} = \frac{\left\langle \Psi(\vec{p})\right|H\left|\Psi(\vec{p})\right\rangle}{\left\langle\Psi(\vec{p}) \right|\left.\Psi(\vec{p}) \right\rangle}. +$$
+ +VQE just means we use a quantum computer to evaluate this energy, and a classical computer to choose how to improve the parameters in $\vec{p}$ so that the energy will be lower in the next quantum iteration.
+ +So whether or not the ""gradient will be will be 0 almost everywhere when the number of parameters in $\vec{p}$ is large"" does not depend at all on whether we are using VQE (on a quantum computer) or just running a standard quantum chemistry program (like Gaussian) on a classical computer. Quantum chemists typically variationally optimize the above energy with up to $10^{10}$ parameters in $\vec{p}$, and the only reason we don't go beyond that is because we run out of RAM, not because the energy landscape starts to become flat. In this paper you can see at the end of the abstract that they calculated the energy for a wavefunction with about $10^{12}$ parameters, where the parameters are coefficients of Slater determinants. It is generally known that the energy landscape is not so flat (like it would be if the gradient were 0 almost everywhere) even when there's a trillion parameters or even more.
+ +Conclusion: The application of Levy's Lemma is going to depend on the particular energy landscape that you have, which will depend on both $H$ and your ansatz $|\Psi(\vec{p})\rangle$. In the case of their particular implementation of QNN's, they have found an application of Levy's Lemma to be appropriate. In the case of VQE, we have a counter-example to the claim that Levy's Lemma ""always"" applies. The counter example where Levy's Lemma does not apply is when $H$ is a molecular Hamiltonian and $|\Psi\rangle$ is a CI wavefunction.
+",2293,,,,,06-12-2018 00:47,,,,4,,,,CC BY-SA 4.0 +2308,2,,2275,06-12-2018 06:52,,3,,"A projection operator $P$ has two key properties: +$$ +P^\dagger=P\qquad P^2=P +$$ +A particularly simple instance of a projection operator is a rank 1 projector, $P=|\phi\rangle\langle\phi|$, which you can easily see satisfies the two properties given that $|\phi\rangle$ is a normalised state, so $\langle\phi|\phi\rangle=1$.
+ +To see what rank the projector is, simply evaluate $\text{rank}(P)=\text{Tr}(P)$. In your state example of $P=|0\rangle\langle 0|+|2\rangle\langle 2|$, you can see that the rank is 2, so it cannot be written as a rank 1 projector $|\phi\rangle\langle\phi|$.
+",1837,,,,,06-12-2018 06:52,,,,0,,,,CC BY-SA 4.0 +2309,2,,2282,06-12-2018 07:57,,0,,"Ultimate Black Box
+ +A quantum computer is by definition the ultimate black box. You feed in an input and you get a process, which produces an output.
+ +Any attempt to open up the black box, will result in the process not happening.
+ +Any engineer would tell you that would hinder any design process. Even the smallest design flaw would takes months of trial and error to trace down.
+",2622,,,,,06-12-2018 07:57,,,,0,,,,CC BY-SA 4.0 +2310,1,2314,,06-12-2018 09:48,,22,5500,"Given a $2$ qubit-system and thus $4$ possible measurements results in the basis $\{|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle\}$, how can I prepare the state, where:
+ +-
+
only $3$ of these $4$ measurement results are possible (say, $|00\rangle$, $|01\rangle$, $|10\rangle$)?
+these measurements are equally likely? (like Bell state but for $3$ outcomes)
+
I'll tell you how to create any two qubit pure state you might ever be interested in. Hopefully you can use it to generate the state you want.
+ +Using a single qubit rotation followed by a cnot, it is possible to create states of the form
+ +$$ \alpha \, |0\rangle \otimes |0\rangle + \beta \, |1\rangle \otimes |1\rangle .$$
+ +Then you can apply an arbitrary unitary, $U$, to the first qubit. This rotates the $|0\rangle$ and $|1\rangle$ states to new states that we'll call $|a_0\rangle$ and $|a_1\rangle$,
+ +$$U |0\rangle = |a_0\rangle, \,\,\, U |1\rangle = |a_1\rangle$$
+ +Our entangled state is then
+ +$$\alpha \, |a_0\rangle \otimes |0\rangle + \beta \, |a_1\rangle \otimes |1\rangle .$$
+ +We can similarly apply a unitary to the second qubit.
+ +$$V |0\rangle = |b_0\rangle, \,\,\, V |1\rangle = |b_1\rangle$$
+ +which gives us the state
+ +$$\alpha \, |a_0\rangle \otimes |b_0\rangle + \beta \, |a_1\rangle \otimes |b_1\rangle .$$
+ +Due to the Schmidt decomposition, it is possible to express any pure state of two qubits in the form above. This means that any pure state of two qubits, including the one you want, can be created by this procedure. You just need to find the right rotation around the x axis, and the right unitaries $U$ and $V$.
+ +To find these, you first need to get the reduced density matrix for each of your two qubits. The eigenstates for the density matrix of your first qubit will be your $|a_0\rangle$ and $|a_1\rangle$. The eigenstates for the second qubit will be $|b_0\rangle$ and $|b_1\rangle$. You'll also find that $|a_0\rangle$ and $|b_0\rangle$ will have the same eigenvalue, which is $\alpha^2$. The coefficient $\beta$ can be similarly derived from the eigenvalues of $|a_1\rangle$ and $|b_1\rangle$.
+",409,,,,,06-12-2018 12:28,,,,2,,,,CC BY-SA 4.0 +2313,2,,2310,06-12-2018 12:30,,12,,"Here is how you might go about designing such a circuit.$\def\ket#1{\lvert#1\rangle}$ +Suppose that you would like to produce the state $\ket{\psi} = \tfrac{1}{\sqrt 3} \bigl( \ket{00} + \ket{01} + \ket{10} \bigr)$. Note the normalisation of ${\small 1}/\small \sqrt 3$, which is necessary for $\ket{\psi}$ to be a unit vector.
+ +If we want to consider a straightforward way to realise this state, we might want to think in terms of the first qubit being a control, which determines whether the second qubit should be in the state $\ket{+} = \tfrac{1}{\sqrt 2}\bigl(\ket{0}+\ket{1}\bigr)$, or in the state $\ket{0}$, by using some conditional operations. This motivates considering the decomposition +$$ \ket{\psi} \;=\; \tfrac{\sqrt 2}{\sqrt 3}\ket{0}\ket{+} \;+\; \tfrac{1}{\sqrt 3}\ket{1}\ket{0}.$$ +Taking this view it makes sense to consider preparing $\ket{\psi}$ as follows:
+ +-
+
- Prepare two qubits in the state $\ket{00}$. +
- Rotate the first qubit so that it is in the state $\tfrac{\sqrt 2}{\sqrt 3}\ket{0} + \tfrac{1}{\sqrt 3}\ket{1}$. +
- Apply a coherently controlled operation on the two qubits which, when the first qubit is in the state $\ket{0}$, performs a Hadamard on the second qubit. +
Which specific operations you would apply to realise these transformations — i.e. which single-qubit transformation would be most suitable for step 2, and how you might decompose the two-qubit unitary in step 3 into CNOTs and Pauli rotations — is a simple exercise. (Hint: use the fact that both $X$ and the Hadamard are self-inverse to find as simple a decomposition as possible in step 3.)
+",124,,,,,06-12-2018 12:30,,,,0,,,,CC BY-SA 4.0 +2314,2,,2310,06-12-2018 12:46,,11,,"Break the problem in parts.
+ +Say we have already sent $\mid 00 \rangle$ to $\frac{1}{\sqrt{3}} \mid 00 \rangle + \frac{\sqrt{2}}{\sqrt{3}}\mid 01 \rangle$. We can send that to $\frac{1}{\sqrt{3}} \mid 00 \rangle + (\frac{1}{2} (1+i))\frac{\sqrt{2}}{\sqrt{3}}\mid 01 \rangle + (\frac{1}{2} (1-i))\frac{\sqrt{2}}{\sqrt{3}}\mid 10 \rangle$ by a $\sqrt{SWAP}$. That satisfies you're requirements with all probabilities $\frac{1}{3}$ but with different phases. If you want use phase shift gates on each to get the phases you want like if you want to make them all equal.
+ +Now how do we get from $\mid 00 \rangle$ to $\frac{1}{\sqrt{3}} \mid 00 \rangle + \frac{\sqrt{2}}{\sqrt{3}}\mid 01 \rangle$? If it was $\frac{1}{\sqrt{2}} \mid 00 \rangle + \frac{1}{\sqrt{2}}\mid 01 \rangle$, we could do a Hadamard on the second qubit. It is not a easy with this but we can still use a unitary only on the second qubit. That is done by a rotation operator purely on the second qubit by factoring as
+ +$$Id \otimes U : \; \mid 0 \rangle \otimes (\mid 0 \rangle) \to +\mid 0 \rangle \otimes (\frac{1}{\sqrt{3}} \mid 0 \rangle + \frac{\sqrt{2}}{\sqrt{3}} \mid 1 \rangle) +$$
+ +$$ +U = \begin{pmatrix} +\frac{1}{\sqrt{3}} & \frac{\sqrt{2}}{\sqrt{3}} & \\ +\frac{\sqrt{2}}{\sqrt{3}} & -\frac{1}{\sqrt{3}} & \\ +\end{pmatrix} +$$ works. Decompose this into more basic gates if you need to.
+ +In total we have:
+ +$$ +\mid 00 \rangle \to \frac{1}{\sqrt{3}} \mid 00 \rangle + \frac{\sqrt{2}}{\sqrt{3}}\mid 01 \rangle\\ +\to \frac{1}{\sqrt{3}} \mid 00 \rangle + (\frac{1}{2} (1+i))\frac{\sqrt{2}}{\sqrt{3}}\mid 01 \rangle + (\frac{1}{2} (1-i))\frac{\sqrt{2}}{\sqrt{3}}\mid 10 \rangle\\ +\to \frac{1}{\sqrt{3}} \mid 00 \rangle + \frac{e^{i \theta_1}}{\sqrt{3}}\mid 01 \rangle + \frac{e^{i \theta_2}}{\sqrt{3}}\mid 10 \rangle +$$
+",434,,,,,06-12-2018 12:46,,,,5,,,,CC BY-SA 4.0 +2317,1,,,06-12-2018 20:23,,11,170,"In [1], the problem of simulating a Hamiltonian using repeated applications of a different set of Hamiltonians is discussed.
+ +In particular, let $A$ and $B$ be a pair of Hermitian operators, and let $\mathcal L$ be the algebra generated from $A, B$ through repeated commutation $^{\mathbf{(\dagger)}}$.
+ +The author then asks (first paragraph of third page) what is $\mathcal L$ for an arbitrary pair of observables $A$ and $B$, and argues that $\mathcal L$ is the space of all Hermitian matrices, unless (quoting from the paper) both $e^{iA t}$ and $e^{iB t}$ lie in an $n$-dimensional unitary representation of some Lie group other than $U(n)$.
+ +I'm not too familiar with the theory of Lie algebras, so this statement is quite cryptic for me. +How can this be shown more explicitly? +Equivalently, is there a more direct way to show this fact?
+ ++ +
$(\dagger)$: More explicitly, this is the vector space spanned by $A, B, i[A,B], [A,[A,B]], ...$
+ +[1] Lloyd 1995, Almost Any Quantum Logic Gate is Universal, Link to PRL.
+",55,,55,,06-12-2018 21:07,12/21/2021 12:06,"Why does (almost) every pair of Hamiltonians generate, through repeated commutation, the whole space of Hermitian matrices?",Simpler answer: All quantum computers are classical computers too, if you limit their gate set to only classical gates such as $X$, which is the NOT gate. Every time you build a quantum computer, you're also building a classical computer, so you can prove mathematically that building a quantum computer must be at least as hard as building a classical computer.
+",2293,,,,,06-12-2018 20:30,,,,0,,,,CC BY-SA 4.0 +2319,2,,2317,06-12-2018 20:58,,2,,"++ +I'm not too familiar with the theory of Lie algebras, so this + statement is quite cryptic for me. How can this be shown more + explicitly? Equivalently, is there a more direct way to show this + fact?
+
At around the same time, David Deutsch et al. proved the same thing in this paper: Universality in Quantum Computation (1995), but without ever using the word ""algebra"" or ""Lie"" in the whole paper. The proof starts on page 3 and the main point is at Eq. 9, which is the same equation that appears in Seth Lloyd's paper, but here it is explained without reference to ""Lie algebras"". Eq. 9 is an application of what in physics we often just call the ""Trotter splitting"". It was written down almost 100 years earlier by Sophus Lie, but you do not need to know anything about Lie Algebras or even vector spaces in order to apply the formula as done in Eq. 9.
+",2293,,26,,6/13/2018 5:17,6/13/2018 5:17,,,,1,,,,CC BY-SA 4.0 +2320,1,2322,,06-12-2018 21:10,,8,118,"If this isn't known, would they theoretically be? I'm particularly interested in knowing whether a QC would be faster at evaluating the fitness function of the possible solutions than a classical machine
+",2637,,26,,6/13/2018 5:39,6/13/2018 15:31,Are Genetic Programming runtimes faster on QCs than on classical computers?,As the title suggests, I want to know what the applicability of quantum network coding is, besides the EPR pair construction between distant pairs of 'Users-Targets'.
+ +Can quantum network coding be used for computation?
+",2422,,26,,12/13/2018 19:53,12/13/2018 19:53,What is the applicability of quantum network coding?,There are quantum algorithms for genetic programming which would theoretically have advantages over the corresponding classical genetic programming algorithms but you would need a full-fledged quantum computer with more qubits than any quantum computer we currently have, in order to observe such an advantage.
+",2293,,2293,,6/13/2018 15:31,6/13/2018 15:31,,,,0,,,,CC BY-SA 4.0 +2323,2,,2321,6/13/2018 6:46,,5,,"Network coding — both classical network coding, and quantum network coding — is an approach to distributing information by performing simple operations at nodes in a network, acting on input signals and transmitting the outputs to other nodes. To put it another way, network coding is an approach to distributing information using a communications network if we treat it as a logical circuit, albeit where the 'gates' performed at each node may be a bit more powerful than just AND, OR, CNOT, or the like.
+ +In principle, we can use the setting of network coding to perform non-trivial computations by an appropriate choice of operations (gates) at the nodes. Network coding does not usually allow the freedom to also choose the structure of the network itself (i.e. the circuit topology), as this is usually given as an input parameter to a given network coding problem. But there will still be some range of computations which a given network can admit, not all of which will serve merely to distribute information.
+ +In the particular case of quantum network coding, the detail that things are to be done in a distributed (and presumably coherent) manner does add wrinkles to how you can manage to accomplish things. However, if we allow classical communication between nodes in the network as well — either allowing classical messages to move both forward and backward within the coding network or in an all-to-all manner — then you can perform coherent quantum network coding for the k-pairs problem +[1] or an arbitrary network coding problem [2] respectively, provided that a classical network protocol exists for the same problem in the same network: and furthermore, the way this is done can be seen to essentially be Measurement Based Quantum Computation (MBQC), as Martin Roeteller and I showed [3]. Conversely, it is fairly clear that for any MBQC procedure, there is a corresponding coding network topology which allows that procedure to be realised.
+ +It follows that, while the details are a bit pickier than in the classical case, quantum network coding can be viewed as a setting in which to do universal computation, specifically via MBQC, at least so long as auxiliary classical communication is allowed (with somewhat fewer constraints than on quantum communication).
+ ++ +
[1] Constructing Quantum Network Coding Schemes from Classical Nonlinear Protocols. Kobayashi et al. (2010). [arXiv:1012.4583]
+ +[2] General Scheme for Perfect Quantum Network Coding with Free Classical Communication. Kobayashi et al. (2009). [arXiv:0908.1457]
+ +[3] Quantum linear network coding as one-way quantum computation. de Beaudrap & Roetteler (2014). [arXiv:1403.3533]
+",124,,124,,6/13/2018 16:53,6/13/2018 16:53,,,,0,,,,CC BY-SA 4.0 +2324,1,2328,,6/13/2018 8:57,,11,1526,"I have some perplexity concerning the concept of phase estimation: by definition, given a unitary operator $U$ and an eigenvector $|u\rangle$ with related eigenvalue $\text{exp}(2\pi i \phi)$, the phase estimation allows to find the value of $\phi$. +This would mean that I would be able to determine an eigenvalue of a certain matrix given that I know already one of its eigenvectors? But isn't the fact that needing an eigenvector beforehand would quite reduce the usefulness of the phase estimation itself?
+",2648,,26,,6/13/2018 9:59,4/27/2022 21:23,What is the actual power of Quantum Phase Estimation?,++ +I am confused what ""conjugation of coordinates"" means in this context.
+
Conjugating coordinates of $\mathcal C$ is equivalent to setting some diagonal elements of Γ to 1.
+ +Read ""Theorem 12, on page 8 and 9"" for an understanding of the usage, this is further explained on page 15 (last paragraph):
+ +++ +""As mentioned before, the set of self-dual linear codes over GF(4) is a subset of the self-dual additive codes of Type II. Note that conjugation of single coordinates does not preserve the linearity of a code. It was shown by Van den Nest $^{[25]}$ that the code $\mathcal C$ generated by a matrix of the form Γ + $ωI$ can not be linear. However, if there is a linear code equivalent to $\mathcal C$, it can be found by conjugating some coordinates. Conjugating coordinates of $\mathcal C$ is equivalent to setting some diagonal elements of Γ to 1. Let $A$ be a binary diagonal matrix such that Γ + $A$ + $ωI$ generates a linear code. Van den Nest $^{[25]}$ proved that $\mathcal C$ is equivalent to a linear code if and only if there exists such a matrix $A$ that satisfies Γ$^2$ + $A$Γ + Γ$A$ + Γ + $I$ = $0$. A similar result was found by Glynn et al. $^{[12]}$. Using this method, it is easy to check whether the LC orbit of a given graph corresponds to a linear code. However, self-dual linear codes over GF(4) have already been classified up to length 16, and we have not found a way to extend this result using the graph approach."".
+
References:
+[12] D. G. Glynn, T. A. Gulliver, J. G. Maks, M. K. Gupta, The geometry of additive quantum codes, submitted to Springer-Verlag, 2004. Book
+[25] M. Van den Nest, Local Equivalence of Stabilizer States and Codes, Ph.D. thesis, K. U. Leuven, Leuven, Belgium, May 2005. .PDF (English starts on page 22)
A couple papers are out there on algorithms which can be constructed using reverse annealing, http://iopscience.iop.org/article/10.1088/1367-2630/aa59c4/meta and https://arxiv.org/abs/1609.05875 (it is worth pointing out previous somewhat related closed system work: https://link.springer.com/article/10.1007/s11128-010-0168-z). As far as experimental results, I think the only ones publicly visible at the time of writing are the white paper given in the previous post. However, there will be some new work presented at AQC 2018 (https://ti.arc.nasa.gov/events/aqc-18/) in late June and these talks are usually put online a few months after the conference.
+",2649,,,,,6/13/2018 9:42,,,,0,,,,CC BY-SA 4.0 +2327,2,,2324,6/13/2018 10:04,,7,,"Sometimes, you might know the eigenvector, and the computational question that you want to answer is what the eigenvalue is. For example, any function evaluation $f(x)$ defined by the action of a $U$ +$$ +U:|x\rangle|y\rangle\mapsto|x\rangle|y\oplus f(x)\rangle +$$for $x\in\{0,1\}^n$, $y\in\{0,1\}$ has well defined eigenvectors, +$$ +|x\rangle(|0\rangle\pm|1\rangle)/\sqrt{2}, +$$ +but whether the eigenvalue is $\pm 1$ is absolutely vital: that is essentially the question being asked in things like Deutsch's algorithm, Deutsch-Jozsa, Simon's algorithm, Bernstein-Vazirani etc. It's also the way that the oracle for quantum search is often constructed.
+ +In a slightly more generalised setting (that applies, for example, to Shor's algorithm), you might not need to find a specific eigenvalue, but a random choice from some subset will do. So it might be that there's a standard state (e.g. $|00\ldots 01\rangle$) that has support on all of the eigenvectors from which you want to pick an eigenvalue randomly, but you have no idea what the individual eigenvectors are, but you can run phase estimation with that input, and you'll be just fine.
+",1837,,,,,6/13/2018 10:04,,,,0,,,,CC BY-SA 4.0 +2328,2,,2324,6/13/2018 10:25,,9,,"If you don't supply a $|u\rangle$ as an input, there are two possible things you might want to get out:
+ +-
+
The $\varphi$ for a randomly chosen (but unknown) eigenstate $|u\rangle$;
+Both $\varphi$ and $|u\rangle$ for one or more eigenstates.
+
Let's first look at 1. Since eigenstates form a complete basis, any input state you use can be interpreted as a superposition of the eigenstates of $U$. Due to the linearity of quantum mechanics, the algorithm would then run for all these states at once. Then at the end, when you measure the output, it will randomly collapse to a given instance. This means that you'll be given a $\varphi$ for a randomly chosen eigenstate, but you won't know which it is. The existing phase estimation algorithm therefore can supply us with the first possible application.
+ +The second application is something we can't do with standard phase estimation, but let's consider it hypothetically. Any algorithm that could do this would be giving us an eigenstate $|u\rangle$ as part of the output. So if you want to actually know what $|u\rangle$ is, you'd have to do tomography on the output. Since tomography is inefficient, there would probably be better ways to go about doing this.
+",409,,409,,6/13/2018 10:43,6/13/2018 10:43,,,,0,,,,CC BY-SA 4.0 +2329,1,2331,,6/13/2018 10:37,,8,213,"If we start with a Hamiltonian $H(t_i)$, and with our qubits prepared in the ground state of this, and then slowly change this to a Hamiltonian $H(t_i)$, the final state of our qubits should be the ground state of the new Hamiltonian. This is due to the adiabatic theorem, and is the basis of quantum annealing.
+ +But what if it's not the ground state we want? Suppose we start with the first excited state of $H(t_i)$. Does the process give us the first excited state of $H(t_f)$? What about for other states?
+",409,,,,,6/13/2018 15:18,Can quantum annealing find excited states?,In Practice:
+ +Quantum annealing almost always gives excited states in practice. To get the exact ground state at the end, you need the adiabatic passage to be perfect.
+ +The closest thing to a perfect adiabatic passage is probably this recent paper where they get the ground state with 0.975 fidelity, but this is for 3 qubits with a very simple Hamiltonian (see Eq. 5).
+ +However in the D-Wave machine with 2000 qubits there's $2^{2000}-1$ excited states and much higher likelihood that many of them will be near the ground state. Almost every problem D-Wave has worked on recently seeks an approximate solution, not the absolute global minimum.
+ +In Theory:
+ +What if my annealer is perfect and we can stay in the true ground initial state the whole time? Yes it should be possible to prove the adiabatic theorem for any initial state, not just the ground state, but how are you going to initialize the system in some particular excited state?
There is indeed a technique for doing ""constrained"" annealing described here. The idea is to use a driver Hamiltonian that commutes with the constraints (see the paragraph above Eq. 2)!
+ +More generally you can adiabatically evolve along a particular symmetry sector. For example if the ground state of a molecular Hamiltonian is a singlet state, but you are only interested in a triplet (excited) state, as long as you start with a state that has triplet symmetry and your driver Hamiltonian conserves spin, you can prove a generalization of the ""basic"" adiabatic theorem that states that you will remain in the triplet state if you evolve slowly enough.
+",2293,,,,,6/13/2018 15:18,,,,0,,,,CC BY-SA 4.0 +2332,2,,2298,6/13/2018 18:29,,4,,"++ +They say that this scheme requires to throw $O(N)$ switches for each memory call, but I don't understand why is this the case. + From the above, it would seem that one just needs to throw $O(\log_2(N))$ + switches, one per bifurcation, to get from the top to the bottom.
+
It seems to me that $n= \log_2 N$ is the length of the address register: the number of times that you have to say left or right to reach a given node.
+ +The number of 'switches' is the amount of hardware required to realize the full graph. For the classical case, this means transistors. From the paper:
+ +++ +An electronic implementation requires placing one transistor in each + of the two paths following each node in the graph. Each address bit + controls all the transistors in one of the graph levels: it activates + all the transistors in the left paths if it has value 0, or all the + transistors in the right paths if it has value 1
+
The number of transistors required for the bottom level of the graph is $O(N)$. This then decreases exponentially as you go up the graph. So the total number is also $O(N)$. All are active, since each address bit activates all the transistors in a given level.
+ +++ +In other words, is the advantage of the bucket-brigade approach only in the higher error resilience in the quantum case, or would it also be classically advantageous, compared with the conventional approaches?
+
I think that it would indeed work in classical RAM, but the hardware constraints didn't supply the 'evolutionary pressure' required for it to be develiped and implemented. The quantum need to hide from errors is the main motivation.
+",409,,,,,6/13/2018 18:29,,,,1,,,,CC BY-SA 4.0 +2333,1,2335,,6/14/2018 1:59,,13,671,"Tried asking here first, since a similar question had been asked on that site. Seems more relevant for this site however.
+ +It is my current understanding that a quantum XOR gate is the CNOT gate. Is the quantum XNOR gate a CCNOT gate?
+",2645,,2645,,07-10-2018 23:34,07-10-2018 23:34,Quantum XNOR Gate Construction,