Approximating Unitary Preparations of Orthogonal Black Box States
aa r X i v : . [ c s . CC ] J un Approximating Unitary Preparations ofOrthogonal Black Box States
Joshua Alan CookJune 26, 2019
Abstract
In this paper, I take a step toward answering the following ques-tion: for m different small circuits that compute m orthogonal n qubitstates, is there a small circuit that will map m computational basisstates to these m states without any input leaving any auxiliary bitschanged. While this may seem simple, the constraint that auxiliarybits always be returned to 0 on any input (even ones besides the m wecare about) led me to use sophisticated techniques. I give an approx-imation of such a unitary in the m = 2 case that has size polynomialin the approximation error, and the number of qubits n.
The problem I focus on in this paper is: given orthogonal states | ψ i and | φ i ,and black box unitary U and V for preparing them from | n i , construct aunitary W that takes | n i to | ψ i and | n − i to | φ i . In particular, it mightuse auxiliary bits initialized to 0, but these bits will always be returned to0 for any input. We show several special cases where we can easily do thisexactly, and show an algorithm to approximate W in time polynomial inthe estimation error. To do this, we also prove some related results such asunitary preparations of rotations between orthogonal states.This problem is in contrast to more straightforward problems in that wewant this to return the auxiliary bits to 0 for EVERY input, not just | n i and | n − i The straightforward algorithm simply uses one auxiliary bit tosee which one of the two input states we are in, and cleans up the control bit1ased off the output. Unfortunately, while this algorithm works on the twoinputs we care about, it doesn’t work on all of them, in particular | φ i , and | ψ i are still problems. While this can still be used in some special cases for | φ i and | ψ i , it doesn’t work in general.If the input and output states are orthogonal, then the problem is easy.Similarly, if the input and output states span the exact same sub space, thisis also exactly doable. But in the general case, we only find that we canconstruct an ǫ approximation of a unitary that gives results these results intime polynomial in ǫ . Exact computation and computation with more than2 output states is still open.I will allow access to the following 4 black box operations with our givenunitaries: application, adjoint application, controlled application, and con-trolled adjoint application. The intuitive reason for allowing these applica-tions is that in most physical implementations of our black box unitary (asmall quantum circuit in particular), these operations would all be available.In solving this problem, I also develop a couple other tools that may be ofinterest. Given an operation that computes | ψ i from | n i that cleans up allauxiliary bits on that input, I give an operation that approximately computesthe component of | ψ i orthogonal to | n i cleaning up all auxiliary bits on anyinput. Further, given such an operation as above, I give a procedure toapproximate an operation that computes | ψ i and does not effect any inputsorthogonal to | ψ i and | n i . Lots of quantum operations are known to exist in theory, but in practiceactually making these quantum operations is difficult even if parts of theproblem are classically easy. One such problem is Q-Sampling, where wemay know how to prepare an appropriate probability distribution over thestates, but only as a mixed state, not as a pure quantum state. In general, weoften have the issue that when computing a desired result, we use auxiliarybits and leave them in a modified state. This can leave our result in a mixedstate that won’t have the desired interference for a larger algorithm.I want to provide tools for preparing quantum states without disturbingany auxiliary bits. This way, the result of a pure input state is always still apure state.I examine the problem of just merging different operations for computingorthogonal output states and creating one operation that computes one on2ne orthogonal input, and the other on another. This is clearly doable intheory, but straightforward algorithms will cause auxiliary bits to not bereset on some inputs. If this is a subroutine in a larger algorithm that mayfeed in one of these inputs to our algorithm, the result will be a mixed statewhich may prevent future interference that was expected.In practice, no practical application of these results are known. But theseresults do give us a class of unitary operations that should exist and gives away to efficiently compute them.
Previous work has investigated how to run quantum algorithms with auxil-iary qubits in an arbitrary quantum state without disturbing them [2]. Inparticular showing Simon and Shor’s algorithm can be done using any auxil-iary bits in any arbitrary quantum state without disturbing them. But thatpaper focused on minimizing the need for special working space bits, whilethis paper focuses on making sure our algorithms leave no garbage on anyinput.The gentle measurement lemma is a huge component of the main re-sult. Gentle measurement lemmas have been introduced in various formsacross quantum computing literature [6], [5], [4]. Most of these focus on thedisturbance introduced by measurement operators if the the result of themeasurement is close to certain. In particular, if one can predict the out-come of measurement Λ with probability 1 − ǫ , then the trace distance tothe resulting state after the measurement is O ( √ ǫ ). We need essentially thissame result except that we don’t actually have a measurement.Thus we prove a related result. Basically, we need a result that says ifsome computation U prepares some bits that are used as inputs in somemixed state to another quantum algorithm acting on another register wheremost of the results yield the other register to approximately compute thesame result, then applying U − will mostly clear the input register.A recent paper greatly expands on what we know about gentle measure-ments on quantum states by relating them to differential privacy [1]. First, I need to solidify notation a little. For n bit, orthogonal quantum states | ψ i and | φ i , we have black box access to unitary U such that U | n i = | ψ i V such that V | n i = | φ i .First, I note that we can controlled apply a gate based on if a state isthe all 0s state. This can be done using the standard techniques of using nbits to calculate the and not of all the bits, CNOTing on the result, thendecomputing. For notation, I call the gate that computes this control M | n i so that | x i M | n i | y i Computes state | x i | y ⊕ ( x == 0 n ) i . Similarly, for any unitary U prepar-ing state | ψ i , we can define M | ψ i as: | x i U − M | n i U | y i which will just apply the control if | x i = | ψ i , but will do nothing to anyorthogonal state. Define W = V U − . This takes | ψ i and gives | φ i . Then we just control apply W conditioned on the | ψ i state and W − conditioned on the | φ i state. Thiswill require auxiliary bits to do but we know which input went to which, sowe can clean up the axilary bits. Note we need | ψ i ⊥ | φ i because otherwiseapplying the controlled not to prepare the auxilary bit would change thestate of the other.I actually give a slightly simpler circuit here though that is easier to proveworks. This one takes | ψ i to | φ i , and in the process of cleaning its auxiliarybit turns the bit indicating that we should take | φ i to | ψ i . See: | x i M | ψ i W M | φ i W − M | ψ i | i • • To see that this works, see that for any input state | x i , there exists state | y i orthogonal to states | ψ i and | φ i and scalars α, β, γ such that: | x i = α | ψ i + β | φ i + γ | y i α | ψ i + β | φ i + γ | y i ) | i→ α | ψ i | i + β | φ i | i + γ | y i | i→ αW | ψ i | i + β | φ i | i + γ | y i | i = α | φ i | i + β | φ i | i + γ | y i | i→ α | φ i | i + β | φ i | i + γ | y i | i→ α | φ i | i + βW − | φ i | i + γ | y i | i = α | φ i | i + β | ψ i | i + γ | y i | i→ α | φ i | i + β | ψ i | i + γ | y i | i =( α | φ i + β | ψ i + γ | y i ) | i This swaps | ψ i and | φ i as desired.Note under the hood, this is applying two of our black box unitaries oneach step, which is 5 steps in total, which is still a constant number. Thismeans that with only constant overhead, we can always assume that theblack box unitaries that prepare an orthogonal pure state only swap the twostates and do nothing else. Now I give an algorithm that takes a unitary U on n + m bits such that U | n i | m i = | ψ i | m i where h ψ | | n i = 0, and constructs a unitary operationtransformation U ′ on n bits which swaps | n i with | ψ i and leaves all orthogo-nal states unchanged. See that this is different then the last case because theinput U might produce garbage on any input other than | n i . Nevertheless,the algorithm is actually the same.We can use the same procedure used above, because U − also leaves nogarbage on the state | ψ i , and we can actually measure whether we are inthe state | ψ i without disturbing any other state. This can be done by justlooking at the measurement circuit: | x i U − M | n i| m i U | m i| y i | x i | m i | y i to | x i | m i | y ⊕ ( x == ψ ) i by writing | x i as | x i = α | n i + β | ψ i + γ | z i Then the computation gives( α | n i + β | ψ i + γ | z i ) | m i | y i→ U − ( α | n i + β | ψ i + γ | z i ) | m i | y i = U − ( α | n i + γ | z i ) | m i | y i + β | n i | m i | y i→ U − ( α | n i + γ | z i ) | m i | y i + β | n i | m i | y ⊕ i→ U U − ( α | n i + γ | z i ) | m i | y i + βU | n i | m i | y ⊕ i =( α | n i + γ | z i ) | m i | y i + β | ψ i | m i | y ⊕ i Then the swapping states algorithm above still works because it only everapplies U to | n i and U − to | ψ i in addition to measurements of whether thestate is | n i or | ψ i , which I have shown none of which produce garbage.This shows that it suffices to get an operation that cleanly computes state | ψ i from any perpendicular state we can efficiently compute to get a unitarythat swaps the two states, changes no other inputs, and produces no garbage. Now, for arbitrary α and β with k α k + k β k = 1, we want a unitary thattakes | n i and gives α | ψ i + β | φ i .To do this, we start with the observation that | n i ⊥ U − | φ i , since h n | U − | φ i = h ψ | | φ i . So letting | ω i = U − | φ i , let us instead prepare α | n i + β | ω i , then we can apply U to this to get the result. Let W = U − V so that W | n i = | ω i .Now the straight forward way to try this is to first prepare a control bitin the desired super position, controlled on it apply U , then based on thestate now being | ω i , flip the control bit back. This works on input | n i , buton input | ω i , we actually get the auxiliary bit set to 1.6ut this can easily be fixed. All we need to do is push the informationabout whether we are in state | n i or | ω i into the control bit before we applythe rotation. Then we will still apply the rotation and clean up the input bit.We also need to take care to clean up the rotation, even on other orthogonalinputs. So, we just prepare a control qubit to only do this algorithm on thetwo important state, | n i and | ω i .So let R be our rotation such that R | i = α | i + β | i . Such a rotationcan be made with arbitrary precision using standard techniques. Then ourquantum circuit will just be: | x i M | n i M | ω i W − W M | ω i M | n i U | i • R •| i • • • Then similar to last time, for any | x i and appropriately chosen scalarsand orthogonal | y i : | x i = γ | n i + δ | ω i + η | y i Applying the circuit gives( γ | n i + δ | ω i + η | y i ) | i | i→ γ | n i | i | i + δ | ω i | i | i + η | y i | i | i→ γ | n i | i | i + δ | ω i | i | i + η | y i | i | i =( γ | n i | i + δ | ω i | i ) | i + η | y i | i | i→ ( γ | n i | i + δ | n i | i ) | i + η | y i | i | i→ ( γ | n i ( α | i + β | i ) + δ | n i ( β ∗ | i − α ∗ | i )) | i + η | y i | i | i→ ( γ ( α | n i | i + β | ω i | i ) + δ ( β ∗ | n i | i − α ∗ | ω i | i )) | i + η | y i | i | i→ γ ( α | n i | i | i + β | ω i | i | i ) + δ ( β ∗ | n i | i | i − α ∗ | ω i | i | i ) + η | y i | i | i→ γ ( α | n i | i | i + β | ω i | i | i ) + δ ( β ∗ | n i | i | i − α ∗ | ω i | i | i ) + η | y i | i | i =( γ ( α | n i + β | ω i ) + δ ( β ∗ | n i − α ∗ | ω i ) + η | y i ) | i | i→ ( γ ( α | ψ i + β | φ i ) + δ ( β ∗ | ψ i − α ∗ | φ i ) + ηU | y i ) | i | i Which when γ = 1 gives the expected state α | ψ i + β | φ i and in all casesclears up the auxiliary bit to 0. 7 Exact Preparation of Special Cases
Now we get to the big question. We want to construct a unitary that takes | n i to | ψ i and | n − i to | φ i . Since the input and output states are orthog-onal, there should be some transformation that does this. But can we doit with just the transformations we have been given? Yes, and in a couplespecial cases we can do it exactly. If the input and output states are all orthogonal to one another, then byusing the state swapping procedure above, we can construct the unitary. Wecan also do it the input and output span the same subspace. span( | n i , | n − i ) = span( | ψ i , | φ i ) In this case we can do the obvious thing, just measure if we are in | n i or | n − i , and if we are, apply the appropriate transformation. Then clean upthe auxiliary bits. Let V ′ be the helper that flips the first bit then applies V so that V ′ | n − i = | φ i .The quantum circuit for this transformation would be | x i M | n i M | n − i U V ′ M | ψ i M | φ i | i •| i • We can make a similar argument as before for the correctness of thisalgorithm, with for every | x i there is appropriate orthogonal | y i so that | x i = α | n i + β | n − i + γ | y i . I leave this as an exercise, but note that thisonly works because | y i is orthogonal to both | n i , | n − i and | ψ i , | φ i , since | ψ i , | φ i define the same subspace. If this were not true, then when we dothe second measurement, some of | y i would be changed and cause garbagein our auxiliary bits. Now we first realize that we can reduce this problem to the case where wewant to swap | n − i with some special | ω i where | n i ⊥ | ω i without effecting8 n i . This is because U − | φ i = | ω i ⊥ | n i , so if we swap | n − i with | ω i ,we can apply U to get the final, desired result.Well, if | n − i = | ω i , then actually we don’t have to do anything, andif | n − i ⊥ | ω i , we can do the swapping procedure described above. If weknow that one of these two is true, then we can apply one of them. Thechallenge is determining which case this is. Well actually these states arevery easy to distinguish: just run U − V on a random | n i auxiliary bits andsee if we get | n − i . Then controlled on one of these, we apply one algorithmor the other, then uncompute the control bit.But we still haven’t covered the general case where | h ω | | n − i | / ∈ { , } :that is they differ by some other angle. But, we can handle the general caseif we are okay with losing a little exactness by examining the properties of U directly. As noted earlier, we can reduce the general case to just the problem of takingstate | n i to some state | ψ i and leaving all orthogonal states alone, given someunitary to take | n i to | ψ i , which may modify orthogonal states. So we willinstead solve this simpler problem given unitary U to do the computation,knowing we can easily translate this solution back.The general algorithm leverages the algorithm we developed earlier formaking unitary rotations and requires two more tools:1. Estimate the angle of the rotation. We do this by running U many timesand summing up the number of the outcomes that were | n i . Aftermany times, with high probability this will get us a decent sample of therotation. After we are done using θ , leveraging the gentle measurementlemma, we can mostly clean the calculation of θ , resulting in a statewith short trace distance from the desired state.2. Getting a unitary to compute the component of | ψ i , call it | ψ ′ i , thatis orthogonal to | n i . This is the part that requires the most care.To do this, we apply U , then we will check whether we are in the | n i state and apply the U again, repeatedly until we have a very lowamplitude on the | n i state. Then, we use the known angle to clearup the working space bits we used when checking if the state was | n i | n i aftermany conditional applications.We then use earlier algorithms to harden this procedure to be unitary,and then the rotation procedure to calculate | ψ i .Of course, the big difference between this case and the special cases de-scribed above is that we will not be computing the results exactly, and thenumber of queries we need to make to U is a function of our error bound ǫ .The actual algorithm has 5 steps:1. Estimate the angle between | n i .2. Find the operation for taking | n i to | ω ′ i .3. Using previously discussed results, make this operation unitary.4. Apply the rotation algorithm previously discussed with the unitary wejust derived.5. Decompute the angle used. Let | ψ i = sin( θ ) | ψ ′ i + cos( θ ) | n i for some θ . Of course to do this, we needto assume that our algorithm is over the reals, and WLOG, we can assumethat.See that for sufficiently small ǫ , − ln( ǫ ) = O ( ǫ ), and − ǫ ) = O ( ǫ ). On − ln ( ǫ ) ǫ copies of | n i , run U and count the fraction of the results that remain | n i . This will give us an estimate of cos( θ ) within ǫ with probability1 − ǫ . This comes from Hoeffding’s inequality [3] which gives that, for H(n)the calculated cos( θ ) on n trials: P ( | H ( n ) − cos( θ ) | ≥ ǫ ) ≤ e − ǫ n = 2 e − ǫ − ln ( ǫ ) ǫ = 2 e ln ( ǫ ) = ǫ The calculated ǫ approximation of cos( θ ) also gives an approximationof | cos( θ ) | with error at most ǫ .One last technical detail is that while we can estimate | cos( θ ) | , we don’tknow whether cos( θ ) is positive or negative. This actually matters because10e are using controlled applications of U . For instance, if cos( θ ) = 1, then θ ∈ { , π } , but we don’t know which. Then if we have state | + i | n i andcontrolled apply U , we will get the state |−i | n i if θ = π , but will get state | + i | n i if θ = 0. So, we need to add one more step to our protocol to figureout whether cos( θ ) is positive or negative.The basic idea comes from above. We first prepare a control bit in thestate | cos θ | √ θ ) | i + √ θ ) | i , then controlled on this apply U to | n i and then if the second register is still in the | n i state, the first bit will eitherbe in the | + i state if cos( θ ) >
0, or the |−i state if cos( θ ) <
0. Of course, wewill have to look at this several times to get a high probability of seeing thisresult, and there is some error in our measured angle we will have to worryabout.If we perform this measurement ǫ times, with high probability we willcorrectly measure the sign if the angle is far enough from π to matter. To bespecific, if | cos( θ ) | < ǫ , then we actually don’t care about the sign becausewe are already close enough to the angle without guessing the sign. Thatis, we already have our approximately orthogonal computing U for the nextstep, and don’t need to find it. Otherwise, with probability at most (1 − ǫ ) n we will see the result at least once, and for sufficiently small epsilonlog − ǫ ( ǫ ) = ln( ǫ )ln(1 − ǫ ) ≤ ǫ = n Thus (1 − ǫ ) n ≤ (1 − ǫ ) log − ǫ ( ǫ ) = ǫ Thus with probability at least 1 − ǫ we will measure the sign of cos( θ ).Now, this measurement can be wrong since we might not have preparedthe state exactly right since we don’t have cos( θ ) exactly. However, sincewe are within O ( ǫ ) of | cos( θ ) | , and we are only considering angles furtherthen ǫ from π , there is an additional O ( ǫ ) probability that we make themeasurement wrong.This is because error is increased by up to a ǫ factor from the probabilitythat we measure the | n i state in the first place being as small as ǫ . Thenthe probability of error is proportional to the square of the sign of the error inthe angle. An O ( ǫ ) approximation of cos( θ ) gives an O ( ǫ . ) approximationof θ . Then the sine squared of this error is O ( ǫ ). So the difference of thestate produced is at most O ( ǫ . ). But this is small relative to O ( ǫ ).11 .2 Approximate Unitary V for Calculating | ψ ′ i To construct this V , it suffices to give a way to calculate | ψ ′ i approximatelyfrom | n i without producing any garbage by an earlier result. It sufficesto only calculate | ψ ′ i approximately because this computation will only becalled a constant number of times by a subroutine. Each time will onlyincrease the trace distance from what should have been calculated by atmost O ( ǫ ), so the resulting V will still give the correct result with error O ( ǫ ).Now I give an algorithm that takes | n i to within ǫ trace distance of | ψ ′ i without producing any garbage, if sin( θ ) < ǫ . If sin( θ ) < ǫ , as measuredearlier, then we don’t do anything and we are already within ǫ trace distanceof the expected state.Otherwise, prepare ǫ auxiliary bits in the 0 state. Then apply U , andconditioned on the result still being | n i , flip the first control bit. Thenconditioned on it being 1, apply U again. Similarly, conditioned on theresult still being in this state, we flip the second bit and apply U again, andso on. After ln( ǫ )ln(1 − ǫ ) < ǫ iterations, the amplitude of the | n − i is at most ǫ . Now, we just need to rotate the working space bits back.Well, we know that the amplitude where the first bit is 0 is just sin( θ ), andthe amplitude that the first bit is 1, given the second bit is 0, is cos( θ ) sin( θ ).Well, we know θ (approximately), so we can just rotate by the appropriateangle to make the first bit 0 given the second bit is 0. Then controlled onthe second bit being 1, we flip the first one. Then we know the amplitudethat the second bit is 0, and the second bit is 1 given the third bit is 0, andwe can apply that rotation. And so on. | n i U M | n i U M | n i U M | n i U . . . | i • . . . R | i • . . . M | i R | i • . . . M | i ... ... ... ...Now, our angle isn’t exactly, cos( θ ) is off by up to an ǫ amount. NowI need to bound how much error each of these rotations has. Well, theangle to rotate by is dependent on cos( θ ) n sin( θ ), and sin( θ ) P n − i =0 cos( θ ) i =12in( θ ) − cos( θ ) n − cos( θ ) , the amplitude of the two states we are trying to rotate. Thenthe angle we want to rotate by is θ ′ n = cos − cos( θ ) n sin( θ )sin( θ ) q ( − cos( θ ) n − cos( θ ) ) + cos( θ ) n = cos − cos( θ ) n q ( − cos( θ ) n − cos( θ ) ) + cos( θ ) n Following Taylor’s theorem, we can bound the error of θ ′ n by its derivativewith respect to x = cos( θ ). The derivative is − q ( − x n − x ) + x n − x n − x (cid:18) − x n − x nx n − + x n (cid:18) − nx n − (1 − x ) + 1 − x n (1 − x ) (cid:19)(cid:19) Now to bound this, we realize that since sin( θ ) > ǫ , cos( θ ) < − ǫ , thuscos( θ ) < − ǫ . Then we can bound the absolute value of the above byWhich absolute value is at most2( nǫ + nǫ + 2 1 ǫ ) ≤ ǫ = O ( 1 ǫ )So the total error is going to be less then this derivative times the maxerror, ǫ . Thus the error in the angle is at most O ( ǫ ). the trace distancefrom applying this angle and the correct angle then is only the sine of thisangle, which is strictly less than this angle, so after each of these rotations,we only introduce an O ( ǫ ) error in trace distance from the desired rotationwhich perfectly cleans up the state.We apply at most ǫ rotations, so the total trace distance from the statethat fixes the garbage bits is O ( ǫ ). And the amplitude on the final state thatcan’t be cleaned with one of these rotations is at most ǫ . So the preparedstate is O ( ǫ ) far in trace distance from the expected prepared orthogonalstate.One interesting thing to note in this algorithm is that in preparing thisstate, we only ever apply U to | n i . So in fact, we don’t even need U to beunitary, it just needs to reset its auxiliary bits on input | n − i . Apply protocol for sending to | n i to | ψ i and leaves | n i unchanged. To dothis, we use the above algorithm for getting the unitary that takes | n i to | ψ ′ i O ( ǫ ). This new unitary is only called a constantnumber of times, so the result still is off from the correct answer with tracedistance O ( ǫ ). θ Finally, we clean up the first step’s calculation of θ . This can just be doneby running the computation in reverse. This works because for the majorityof calculated θ , the result is within ǫ trace distance of the desired state, andonly an ǫ fraction of the calculated θ is farther than that.To make this explicit, for potential calculation of θ , θ ′ , let S θ ′ be the setof states that during calculation would have yielded θ ′ , and for x ∈ S θ ′ let α x be the amplitude on that state. Then the last two steps are a function f θ ′ : R n + m → R n + m , and the result of the algorithm at this point is: X θ ′ ( X x ∈ S θ ′ α x | x i ) | θ ′ i | f θ ′ ( y ) i for input y. We also know that for some unitary W which swaps | n i and | ω i , does nothing for any orthogonal input, and leaves all auxiliary bitsat 0, for θ ′ ∈ ( θ − ǫ , θ + ǫ ), | f θ ′ ( y ) i is within trace distance O ( ǫ ) of W | y i .And finally, if we let R be the set of calculated θ ′ within ǫ of θ , or loosely R = ( θ − ǫ, θ + ǫ ). Then we started by showing that X θ ′ ∈ R X x ∈ S θ ′ α x > − ǫ Or X θ ′ ∈ R c X x ∈ S θ ′ α x < ǫ So first, we see that if we consider the ǫ fraction of the inputs that are faraway from the real θ , modifying them to have their result be the unitary weare approximating is only O ( ǫ ) trace distance away. This is because the tracedistance of pure states | a i , | b i is just p − h a | | b i , and the inner product ofthis perturbed state with the original is just14 X θ ′ ∈ R ( X x ∈ S θ ′ α x h x | ) h θ ′ | h f θ ′ ( y ) | + X θ ′ ∈ R c ( X x ∈ S θ ′ α x h x | ) h θ ′ | h f θ ′ ( y ) | )( X θ ′ ∈ R ( X x ∈ S θ ′ α x | x i ) | θ ′ i | f θ ′ ( y ) i + X θ ′ ∈ R c ( X x ∈ S θ ′ α x | x i ) | θ ′ i W | y i )= X θ ′ ∈ R ( X x ∈ S θ ′ α x ) + X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) h f θ ′ ( y ) | W | y i =1 − X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) + X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) h f θ ′ ( y ) | W | y i > − X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) > − ǫ So the trace distance of these states is less than p − (1 − ǫ ) = √ ǫ − ǫ = 2 ǫ √ − ǫ = O ( ǫ )Now we perturb it again, this time only modifying the inputs that areclose to θ . There are a lot more of these, but each of them is only tracedistance O ( ǫ ) from W | y i . Intuitively, this should imply that the combinationof these with an unperturbed state should also have that trace distance. Butto make this concrete, lets calculate the trace distance explicitly. To say | f θ ′ ( y ) i and W | y i have trace distance O ( ǫ ) means that for some constant K : h f θ ′ ( y ) | W | y i > √ − Kǫ . Thus when we look at the inner product of thelast state with the perturbed state, we get:( X θ ′ ∈ R ( X x ∈ S θ ′ α x h x | ) h θ ′ | h f θ ′ ( y ) | + X θ ′ ∈ R c ( X x ∈ S θ ′ α x h x | ) h θ ′ | h y | W − )( X θ ′ ∈ R ( X x ∈ S θ ′ α x | x i ) | θ ′ i W | y i + X θ ′ ∈ R c ( X x ∈ S θ ′ α x | x i ) | θ ′ i W | y i )= X θ ′ ∈ R ( X x ∈ S θ ′ α x ) h f θ ′ ( y ) | W | y i + X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) > X θ ′ ∈ R ( X x ∈ S θ ′ α x ) √ − Kǫ + X θ ′ ∈ R c ( X x ∈ S θ ′ α x ) > √ − Kǫ
15o the trace distance of these states is less than q − √ − Kǫ = √ Kǫ Therefore, the trace distance fixing after fixing these states is O ( ǫ ). There-fore, the trace distance from the original state, to what we wanted to calculateis O ( ǫ ). That is, tr ( X θ ′ ( X x ∈ S θ ′ α x | x i ) | θ ′ i | f θ ′ ( y ) i , X θ ′ ( X x ∈ S θ ′ α x | x i ) | θ ′ i W | y i ) = O ( ǫ )And what we wanted to calculate is independent of the first two registers,so when we undo the counting procedure on it, we perfectly clean up theinput bits and have calculated what we want. Thus when we apply this toour actual state which is O ( ǫ ) close to this state, we end up O ( ǫ ) close tocleaning up the input bits and calculating what we want. There are a few open questions about this problem.Even though this algorithm is polynomial in ǫ , the polynomial is huge, O ( − ln( ǫ ) ǫ ) since angle estimation is by far the slowest part. Its very rare forsimple algorithms to require such large run times. Some of this could bepotentially improved with a more careful analysis. But likely, to get muchbetter, we need a more efficient technique to calculate | ω ′ i . Can this be done?Although this result only approximates the correct answer, we haven’truled out an exact computation that runs with constant queries. This canbe done easily in a few special cases discussed above, but seems very difficultin general. Is It?This algorithm only works for transforming 2 orthogonal input states to2 orthogonal output states. The algorithm seemed to rely on the fact thatit was only 2. Can we extend it to work on a bigger set of input and outputstates? 16 eferences [1] S. Aaronson and G. N. Rothblum. “Gentle Measurement of QuantumStates and Differential Privacy”. In: to appear in Proceedings of ACMSTOC’2019. (2019). url : .[2] Dong Chi, Jeong San Kim, and Soojoon Lee. “Quantum Algorithmswithout Initializing the Auxiliary Qubits”. In: Physical review letters doi : .[3] Wassily Hoeffding. “Probability Inequalities for Sums of Bounded Ran-dom Variables”. In: Journal of the American Statistical Association doi : . eprint: . url : .[4] Mark Wilde. From Classical to Quantum Shannon Theory . 2011. url : https://arxiv.org/abs/1106.1445 .[5] Mark Wilde. “PHYS 7895: Quantum Information Theory, Lecture 16”.In: (2015). url : .[6] Andreas Winter. “Coding Theorem and Strong Converse for QuantumChannels”. In: IEEE TRANSACTIONS ON INFORMATION THE-ORY doi : . url : https://arxiv.org/abs/1409.2536https://arxiv.org/abs/1409.2536