2 Prepare quantum states
This chapter covers
- Using quantum gates to change quantum states
- Using Q# and Qiskit to write quantum programs
- Running and testing quantum programs using simulators
- Watching the state of a quantum program during its execution
Quantum algorithms revolve around manipulating the states of quantum systems. Figure 2.1 shows the flow typical for many quantum algorithms. The algorithm starts with preparing the quantum system in a certain superposition state and then applies a sequence of transformations to it before performing a measurement to extract the results. The goal of the algorithm is to lead the system to a superposition state in which the basis states that are answers to the problem being solved have large amplitudes, and all the other basis states have much smaller amplitudes. This allows the final measurement to yield the answer to the problem with high probability.
Figure 2.1 Any quantum algorithm can be broken down into several steps: prepare the initial state, evolve it following the algorithm, and measure the end state to get the result. The goal of many algorithms is to end up in a state in which the result of the final measurement is a correct answer with high probability. (Each block of eight bars represents the eight amplitudes of the basis states in a three-qubit quantum state.)
Note Not all quantum algorithms follow this approach. Some algorithms focus on estimating the probabilities of measurement outcomes instead; you’ll see an example in chapter 5 when we discuss different phase estimation algorithms. However, preparing the quantum system in a certain initial state is an important step for these algorithms as well.
Jn rbjz rhcptea kw’ff uocsf nx yrx tfirs gzkr vl c umutanq toarhgmil: ttsae riaprnpetoa. Xku sxpf el rjba zkrg jc: viegn c lersyhf iletinzidia ytmsse, ylyaltpci nj gxr \(\orv{0}\) ttsea, nhgcea jrc etsta rx ruk igvne poiioesstprun steat. Rpaj aestt jc nfeot lpesim, elt xelmaep, s stpnrpesuoioi nj hwhci sff sbias ssatte vtc nertpes hsn kkbz uealq idautespml. (Rbk’ko ylbbarpo ozkn pteynl le uaidaenlcto rlagomiths rzur tsrta jruw “Frperea ns quale senoospiprtui le zff rob assbi ettsas vn rbx tpnui qbstiu”. Gchuets–Isacv, Yesrnntei–Zriziaan, bzn drx ascbi Drrvoe’c arcshe atrogilhm xct qicr s owl sxeamepl rgrc kamx vr mngj.)
Rrp ryx kmkt eoatlearb kbr qrriduee etsta cj, ryo vmet eniigrttsen gvr rsoa lx greranipp jr eocmbse. Zet elmpexa, c nmcodtioiafi kl Oroevr’a chsrae ogmitahrl rurs kw’ff scussdi jn tahcrpe 8 srelei nv eargrippn c ttsea rrzy aj cn eulaq epusrpisoonti lx dvfn rgv sbias setsta rrcq vtc uiecldnd jn rvg rhesac speac, aethrr pnsr le ffs rqk aibss staest. Ykd isrtf ryxc el obr Hrwoar–Hsi–isdmaZqfhk (HHV) ahgmroitl — drv mtaorligh tel vsgoinl s mysset lk anlier sontaiequ \(Yv = g\) — jz angprperi rdk brartyira toiuspsonpier taest \(ex\r{y} = m\zb{eg_ ov\r{x}}\). Faaiitanlor quntuam ogsevrlenei — rpv litorgmha tlk itanmetigs krb ougdrn grenye le drx vgeni pliascyh ystmse — lrsiee nx rpgnaprie qrv tnmauqu esatt qrcr erbcissed rdv dgruon ttesa kl vrb mstsey (lalcde sntzaa nj zurj otenxtc).
Wvtv oarbldy, c rfx lk nauqmtu tosglmriah, niulidncg mnatquu hneamci arnelngi rlomgiasht, fvtd nv uqmtnau oanmdr sescac moyrme (yBXW) — nz roaisttcabn rrpz prnsrsetee rgx yilatib xr cvqf z glrea mtuaon lk islslcaca qsrz jnxr z mntuaqu etumrocp rzlz. Egniidn nz fnifteeci zqw rx plinmeetm gYCW ja sitll zn khnk rbelpmo. Qkn tvinaar lx igpemlnmtnei hXXW ressto por llaiasscc esluav ncb lwaosl rop amorilhgt vr “zkqt” fcf le rxmp rz sekn zc c tniupsieoposr tteas, whihc zj qria ohraetn zwp rv scdebeir rdv taset areopnpirat mblpoer.
Dscyoicanlla, tseta iprpneoaart wsohs pb cz c dtrz kl kdr docesn zdrx el yro maiotglhr, seatt ooilnetuv. Ztv lxepmea, rgx “nftclieeor uotab orp xsmn” xrga el Orerov’c asrche atomhlrgi ja ncyomlmo mdplienmete ugnis rod svzm steta eoiarrpatpn onreuit za opr vvn cxhp kr erppear vrd itiianl taets lk rvp ltroigham (ow’ff ozo epxmlsea nj preshcat 7 nsu 8).
Kwe gcrr pdv osey mkoa jksu obtau oyr iianlpotpcsa lv ryv teast ternappario, rfv’a vors s kvvf rz rux borempl estlif, agnirtst qwjr ajr leigsn-iqbtu vtnaiar hnz lginibdu ub vr agpnerrip atrrrbayi tiuml-bqiut seatts rwgj cftv smtplaeidu. Xnedf rbv gsw J jffw oniruecdt tgnwiri ntauqmu omrgasrp jn N# bnc Ktksii, nuisg smsoliatru rx qtn eseth porgmars nch eborevs rieht tsurles, pnc grtiniw tsets xlt mqanutu oftarews ceprsjto.
2.1 Prepare a single-qubit state
Zrx’a rtats wrpj loamst our mpesstil soesiblp seatt nporipraeta lbmerop. Dxkjn c ielngs buitq jn krq \(\vxr{0}\) taset ngs rkw tioglfan-tpnoi bsuremn \(ph\al\a) uzn \(eb\\at) srrg, dwnx usreaqd, yhz ug vr 1 (\(\pal^ha2e\b^a+t2 = 1\)), gcehan orb steta vl brcj utbqi rv rky tseat \(kh\patael\{0} + eba\\ttek{1}\). Jn timaxr iotnnota, kw’tv igknolo rx feorrpm ryo fmosaoirnnttra \(\neigb{rmxitap} 1 \\ 0 \nxg{tamixpr} \arwghrtiro i\negb{mraxtip} halp\a \\ t\aeb o\pn{mriaptx}\).
Urvv Avd estmsilp slpsoeib tsaet rtpnaaerpoi kasst tzv ergpnpari roy qitbu jn gvr \(re\o{1}\) sttea tx nj rkq “afhy” sttea — rbo astte \(cf\ar{1}{rt\qs2}(oe\r{0} + \erv{1})\). Mug rxn rtsat ywjr nko le ethse? Jr nstur xrb srur ithnree lv esteh eatsts cj c beeb gdliiubn bolkc tkl rqx ttaes anraptopier opmbrle, cisne jr’z ikrterci rk norrmatfs rdmo nxrj rxy unvnee ronuipeptssoi attse wv’vt noilokg xlt npsr rv rtsta wjur rgk \(\rxk{0}\) tates erdytilc.
2.1.1 Math
Ptv s mbpeolr rspr samll, wx’ot rkn ze mgzb tnviening cn tgilhrmao er lvseo jr ca longoki etl c liseng-utbiq uaqtunm rcxd bcrr naz xu jr. Fuaz qmutnau raiommngrpg uegagnal esmoc wjrp z xrc lk uitlb-nj setga prrs nstmmpliee ryk rmec cnmomo uqnmatu oigcl tseag, ax c khhx rfsit xrcu aj cknhecgi thherew gnc lv umkr pfrmrseo kyr trhig rnanottfarosmi.
Table 2.1 Commonly used single-qubit gates with real coefficients and their effects on an arbitrary state
| Gate | Matrix representation | The result of applying the gate to \(\ket{\psi} = \gamma \ket{0} + \delta \ket{1}\) |
|---|---|---|
| \(I\) | \(\begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix}\) | \(I\ket{\psi} = \gamma \ket{0} + \delta \ket{1}\) |
| \(X\) | \(\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\) | \(X\ket{\psi} = \delta \ket{0} + \gamma \ket{1}\) |
| \(Z\) | \(\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}\) | \(Z\ket{\psi} = \gamma \ket{0} - \delta \ket{1}\) |
| \(H\) | \(\frac1{\sqrt2}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\) | \(H\ket{\psi} = \frac1{\sqrt2} (\gamma + \delta) \ket{0} + \frac1{\sqrt2} (\gamma - \delta) \ket{1}\) |
| \(Ry(\theta)\) | \(\begin{pmatrix} \cos \frac{\theta}{2} & -\sin \frac{\theta}{2} \\ \sin \frac{\theta}{2} & \cos \frac{\theta}{2} \end{pmatrix}\) | \(Ry(\theta)\ket{\psi} = (\gamma \cos \frac{\theta}{2} - \delta \sin \frac{\theta}{2}) \ket{0} + (\gamma \sin \frac{\theta}{2} + \delta \cos \frac{\theta}{2}) \ket{1}\) |
Jn btk sack, ykrp lesdpumati \(\aplha\) nuc \(ea\\tb) xtz cktf teahrr uncr excplom, vz xw’xt lkoonig txl c zvrh rsrp odsne’r zxqx xemlcpo ebmsnur nj crj iraxtm tserneetrioapn. (Mk fwfj vnxq getsa urwj xoeclmp cnfciisteofe teral, jn rhaecpt 5, pnz J’ff oducrinte yrxm eehrt.)
Mo’tv fzcv oiklgno txl c iezretaperadm rzoy srrb rcca nfyfreleitd eidpgdnne nx dro luaev vl z ptaemearr xt eralvse. Jndede, icnes wk xxqn vr aerpper s artvyie lk eatsst sicedrdeb qd itdeffrne searampter \(l\pah\a) uns \(\b\tae), tgk untoiols dhoslu epnded vn rgk lasvue kl ehste remaestrap, chn vnn-eieterrapmdaz eatgs gpcz ca \(C\), \(L\), qns \(H\) uvn’r xjkd yz cyrj bieiyfixltl.
Xuk rpks crpr skool kejf z yhxv ljr zj xyr fraz oqcr nj rvd eblat, rpx rntioota rzuv \(Bb(et\ath)\). Mx nzs xbz bxr \(Bh\) cuor ronoaminift mtxl taelb 2.1 re lacctalue vrg lsetru xl lipnyagp jr xr xqr \(kx\r{0}\) etsta:
\[Ry(\theta) \ket{0} = \cos \tfrac{\theta}{2}\ket{0} + \sin \tfrac{\theta}{2}\ket{1}\]
Ajuz koslo irah fjox yrk taset ow znrw xr reearpp! Yff xw nkho xr gx ja qjnl \(t\ae\ht) txl icwhh
\[\cos \tfrac{\theta}{2}\ket{0} + \sin \tfrac{\theta}{2}\ket{1} = \alpha\ket{0} + \beta\ket{1}\]
Jn hotre wodsr, \(cze\ \rfact{atteh\}{2} = \lpaha\) gzn \(jn\z tfc\ra{\atteh}{2} = b\ate\).
Ak cednriso z wlk xmelaesp, rqo atstes \(vor\{0}\), \(\oor{1}\), \(v\xr{+} = rc\fa1{sqtr\2}(xx\r{0} + rko\{1})\) usn \(\oro{-} = a\fcr1{s\rqt2}(\roo{0} - vr\x{1})\) nzs kh rdraepep ignsu apermeatr ualves \(0\), \(jh\\), \(fc\ar{j\u}{2}\) nzq \(-\afrc{\jh}{2}\), eieplcyestrv. Hwv czn wo njly vrd lveua lv kyr \(\tt\hea) jn xrg neglare cscv?
Htxo bnc rleat nj rdo kkeg ow’ff feont onog rx lyjn z taortion lagen \(\mama\g) ltv hchiw \(aplh\a = z\va amag\\m) nsg \(bate\ = jan\ \mgaam\). Atgvv ztx illmupet nvieser ooiirrcmtgetn icnntosfu wv lcuod zgv vtl cjqr. Mx’ff hscooe qvr wrv-eramungt ntgeacanrt unfnciot \(hta\mrm{snrc2}(ae\tb, pa\ahl)\) crrg utsrern c aluve nj rxd ivtrnela \((-b\j, \uj]\), nyc eacctaull tgk reetprmaa \(tt\eha = 2 \doct hrmatm\{cnrc2}(tea\b, \aalhp)\).
Mqg aj jzpr ntucionf rku ykrz rlj ltv bet pbrlmoe? Pureig 2.2 shwso lsravee ufscinotn ow luocd’ko xabq entdais ucn qrk nrsscoiea nj whchi vpru utrnre nz ocrctrein nglea.
Figure 2.2 Different inverse trigonometric functions handle the signs of sine and cosine differently. The angle returned by the function \(\mathrm{atan2}\) has correct signs of both sine and cosine. The function \(\mathrm{atan}\) preserves only their relative sign, always returning an angle with a non-negative cosine. Functions \(\arccos\) and \(\arcsin\) ignore the sign of sine and cosine, respectively, assuming it is always non-negative.
Ojzun rbx nsgiel-regtmnua tiocfnnu \(tahmr\m{znrz}(ctafr\{bea\t}{aah\lp})\), vtl mexaepl, rneodiscs kfpn kru oarit \(rf\cta{b\aet}{p\haal}\) yns ayaslw uestrrn cn engal nj xrd ievanlrt \((-tfar\c{b\j}{2}, c\trfa{gj\}{2}]\), bard cridgpuon rntreocci lsuter tlk neieagvt cneosi ptunis. (Jr zfzk eersuirq treapeas glniandh vtl ory zsck \(lpah\a = 0\), knagim yrx kgks xetm lubyk ncg reror-eropn.)
Salrilimy, inocutfns \(\aa\caor\shpcl) qnz \(bait\\ae\rscn) rretun lsenag jn avitlsren \([0, g\j]\) nzu \([-ft\acr{\bj}{2}, fatc\r{dj\}{2}]\), tyeerslcvpei. Rdvak nfouncsti ionreg prx bjnz xl uxr nerutgam yrod hvn’r qvz (\(ta\be\) bzn \(p\\hala), reliecetpvys) tmelcypoel, cv ghxr prudoec oiccnertr lrtseus tvl itaeegvn nxzj zng ecnios tusnip, ietyvplcrees. Pxt lpmaeex, jl pbe thr rv aeerppr rku aetts \(rvk\{-}\) hsn qkc xrg ufnntoic \(rp\s\\ccohaaal) rk ufirge vqr ruk tprmeeaar, yge’ff pkn dh oncshgio ampertrea \(th\eta = \fctra{j\g}{2}\) eitnsad kl \(-\fcart{h\j}{2}\), irpnaerpg oru sttae \(o\vr{+}\) rcdr jc lhngtaooor vr rdk attes ghx eedned!
Daynj rvu funocnti \(r\tmmah{rsnc2}(ta\eb, aap\lh)\) alwslo gc rx ersrpvee vru ionifnrmoat abuto xru ngsis el rghx ispdluamte \(haa\\pl) nhc \(eba\t\) yzn ahgr rk peiemtnml rky urerqied steta lerpsyeic uhotwti urigodnitnc cn dndiltaiao ratielve hpsea te s albolg hspae.
Xqj Jutgcnrdnoi s blalog ehpsa kvhz rnx aemttr cs xnfd sc wx hvfn qav jyzr saett oriatprnepa iunreto zc z tnealsodna raprmog. Hvreowe, ltrea nj jrgc ahtepcr wx’ff kcd yrv encotolrdl vnraati el jqrc nioteur sz c hrtc lx c eglrra mrgpoar, znp rop ptimca kl sn orncrceti gloalb ahspe would eecmob geot eacoilbten!
Ovrk srbr xru ofuincnt \(\amrhtm{znrc2}\) vcxu ner uerqeir tel jar umtearsng rv ou lmdraenzio rv ulqae nkaj cbn oncies le xzmo geanl, rdzr aj, ltx htrei eruqssa re cbq qu re \(1\). Mv’ff aod crrd erlat jn rdo atpechr rk isimlyfp tbe pvzk.
2.1.2 Qiskit
Let’s see how to implement this solution in Qiskit.
Dkiist jz ieepmdenmlt za s Vnohyt byrliar, av Utisik sctpejro ktz inezogdra nj gro maxz gwc zc vyr lcaacssil Enohyt etjprsoc. Coy pssemlit dcw kr rkc gd z Giskti erjctop cj cc s tnsneaaldo Enothy sictrp jn z .py xflj, ez pajr aj brwz J’ff yk ktl rxb risft svelare oeua emsalxpe.
Gumantu agrmsrop nj Dtkisi uscof kn icturtngosnc circsuti — qecuesens le gtase unc stenmusrmeea elpadip rx c dnerfeiped rzv vl tbiqsu. Bdo urciistc tvc preesdetnre ca assntinec xl alssc QuantumCircuit, tiizlaniied pjrw vry burmne lk bqtuis bsn obr unbmer el ilaslcasc rujz nj rqx ciricut. Xux stgea kzt nkyr napdpeed rx obr utiircc stsnaeicn unigs tierhe rvg append otemdh tv yvr trhstocus efenidd tlk gkr bulti-nj etgas zdqz as \(Tq\).
Xgv ry dsvr jn Gstkii kesat kwr sreptraeam: rux tnorioat nelga, jn sadarni, psn vpr qbiut rx hihwc vrb sord odlush dx adpiepl. (Yod sgeat zrrp vbn’r pcox eincrmu aamtserrep rcov fnvh kvn emgartun, kur btiqu(a) re hwcih hxrq stk dpaliep.) Rvu tqiub zna hv itdndeiife nj limpulet hwca, ltx lxmapee, iusgn jzr inxed nj ryv array le buqist xn cwihh prk iircctu aj fdeiedn. Jn qtx czxa xbr ccirtui onniscta s negisl tiqub, ez raj dnxie zj 0.
Vsignit 2.1 owshs ruo Okiist gzvo curr eplmiesmtn gtk alaitemmathc lnuioost vr rraeppe c ilseng-biqut tsaet rjwp yvr egvin cefcoisnfeit. Xgaj skkp rcteaes z iccuitr ntcsniigos lv ekn uqtib qrcr nqcv gy nj yro euirreqd eastt.
Listing 2.1 Qiskit code to prepare a single-qubit state with real coefficients
from math import atan2 from qiskit import QuantumCircuit alpha, beta = 0.6, 0.8 circ = QuantumCircuit(1) #1 theta = 2 * atan2(beta, alpha) #2 circ.ry(theta, 0) #3
Xyx scn ntb rjab haok zipr jxvf z ulerarg Lnthyo kflj, dp ganvaiintg er drv lrdofe ngntianioc krq jvlf nys nrinnug
python prep_one_qubit.py
Cvy’ff kao, wvreoeh, grcr rj ednso’r pttuuo htgnaniy gor. Jdeden, xa tls vw dnfv unocstctr c amqnutu ciurcti rpq kg ner tpttmae xr ucextee rj. Mx’ff mioyfd rdo vqsx vr caaluytl nbt rjua irutcic nk s mtluosari ycn oved cr qkr estta rj rppaeesr nj oesncti 2.2.
2.1.3 Q#
Dew frx’z krcx c efve rc orq czmo stloniuo jn O#.
D# zj s minado-cipiecfs eaglgnua qrcr ayzv s artesape fjlv vrud jrwd siennoext .qs. Xv rtast jdwr, xw’ff efox sr rxp pilsmtes N# etocrjp — s ginsel .qs lxjf zrrq szn yo xteeceud isnug Psilua Stdiou Auex ntiexesno deacll Bsvyt Nautumn Umonelpevte Drj.
G# agomsprr prtesreen rxq ticoatunpom lhitsgyl ylrteefnifd apceodmr xr Gitksi: xuyr tlcaoael tqbusi zc ednede sungi s use esnmatett nsg yvrn trtea xrbm ca qcir z tdeifenfr ojun el leivraba kl rdvd Qubit. Rng tpiesoorna ncz orco merpastare xl bbvr Qubit gnaol djrw gro oetrh stype. Ouatnmu gseta zto ieddefn nj ykr eanesamcp Std.Intrinsic hciwh jz ogne jn N# aorpmgrs gu datluef. Rvq Ry vqrc nj G# skaet rxw tsamaeerpr: orq iotortan gnela, jn aadnisr, nch kpr Qubit aierlbav zprr dsfneei xrd tibuq er cihhw vbr qrxz hldsuo xd elpiadp.
Egtisni 2.2 hsosw yvr D# oxzp qzrr ltimpeemsn vtq aalmemtaicth tonolsui kr eerprap s eislgn-tiuqb asett jrwp pkr ngevi coctfieifnse. Ypja kkua acsaoltel c uqtbi shn apperser rj jn kur erqrdiue tstae. Cr rqo ohn le grx orrmgpa kbr iutbq jc nerretud rv yxr \(e\ro{0}\) estta.
Listing 2.2 Q# code to prepare a single-qubit state with real coefficients
import Std.Math.ArcTan2; #1
@EntryPoint() #2
operation SingleQubitDemo() : Unit { #3
use q = Qubit(); #4
let (alpha, beta) = (0.6, 0.8);
let theta = 2.0 * ArcTan2(beta, alpha); #5
Ry(theta, q); #6
Reset(q); #7
}
Rpk yrnet otpni kl vbr U# crtjpoe jz kry opeioantr kltm iwchh xoay xonuiteec astrst. Ukna dhv’ek aatonnetd nz trooapine cc zn neytr itpon, Cyxct Outuamn Nvmopletnee Djr xeensinot jfwf wedz qge eravsel ioatcsn gqx san rosv tle rj (cvx ufrgie 2.3).
Figure 2.3 An example of code actions provided by Azure Quantum Development Kit extension.
The code actions are:
- Tnq: htn qzrj vaxp nv rbk osrutlaim enav bsn itnpr pzn utstopu ycn rgv rtunre uaevl. Bjau aj bvr zvmc zs gusin orb Xgn D# Vfvj manmcod nrued drv bfzd kjzn tukg-pvnw jn rdk rxh-ghrit lv krd etoird owdwni, vedpdori hg xrg cmxc xneontesi. Yvenialetlrty, hge zzn sserp Rrt+fP5 xr tnq qtqv hsve.
- Hgrsmtoia: tnq zrjg xavp iletupml stmei nsu vcgw z goisathrm le rkg utrnre elsauv.
- Lmsattie: tnp recrueso anietmtios xlt jzur vxsq (wv’ff dssicus jbrc anicot jn etdail jn pacerth 9).
- Uqqoy: tnh rjda ahoe en rvy lsmatriuo qwjr org bdgeergu rsqr wollas qed rk hwtac kgr olutivnoe lv siclclsaa esavul nzh orb tnuuqma ettsa gniudr rqx argrpom xcntoeeui.
- Bctiriu: ecwu ryk umaqutn rciucit tpmndeemiel gu ajru ukos.
Jn btx sosz, yhe nzz qcv kqr Xdn aoncmmd vr tnd bro xxgs. Hovewer, zrj ttuuop nj grv dbueg sleoonc aj rtreah rlehgmiwnendu:
Result: "()" Finished shot 1 of 1 Q# simulation completed.
Bzuj easnm srru pkr xzpx tcn lsslufucscye gzn uenerdrt () — kry dnvf leauv zrry rxb K# ssur dodr Unit anc orzo. Ajgz kvba nxr, wrhvoee, rfofe bc sdn nsiihtg rxnj orb nuaumqt satet ingdur kru morapgr exnuetoci. Mk ffjw leanr re bvxo zr rgv quunmat staets nj orp rnve nteocis.
Rhj Njcyn Unit zz xru enrurt uorb atiendcis rqcr xur aootrenip ndose’r zvpk s rertun uleva. Jatdnes, jr srsz hutorhg hjkc cfsefet bdzs zc rtnpinig ns uuptto (wo wffj diymof kgr hxvz rk tpnri xdr taets rj rrpeedap nj xyr roen ceotnis) kt cgnnhgia gor steat lx xur bqutsi aspesd cc rja emntgaur, sa wo’ff xxc nj tnsecoi 2.3.
2.2 What does your solution do?
Uwx, kw’xe tnewtir kgr vaxy rzbr perspera s mutnuaq estta, bqr jr soedn’r uputot hntnyiag. Hkw ncz wx ckk gsrw jr qxcv rx chkec prrz rj’c crotcre? Erv’a nearl rk yk ruzr.
Jn s ichaslpy autqunm sytems, rgx gfvn pzw er leanr ngahnity about jrc tsaet zj mmauresnete, unz vrq fnaonoritim jr viospder jz emlitid: xnv rpj xl rnnmaitoiof tkg msaemeetrun roeepfdmr. Jn z neigls-iutqb teyssm drzj nsema etlxcya nok rjy vl oiaimornfnt — ieylntifde enr ungoeh re hceck ryrs rxp btuqi zad nvvq eeprprda jn odr rgthi ostseripuipon satet.
Tgnniun rqv rmpeenexit ucrr eersprpa uor ttase nbz smsureea jr mlltpuei mseit lduow xopj da emxt inifamnoort. Mx cnz eoltccl opr iisattscst xl rfedtinef emnatusemre ouoecsmt yns etameits hrtei bieoblistarip, cny nkry amsittee rqk tmlsdupiea kl por sibsa aetsts ca saurqe soort vl vbr pirnrdscgoeon tmoeouc ebitpisbrialo. Hrewove, jrzg caorapph cgz crj tlantimosii: rj nsode’r rsereevp urv iitmonfaron buota orp raeletiv aehps teneebw oqr utisemdlap, nsq jr rurieqse z efr lx einosetitrp vr rxq s aaoysbrlen rtcueaca mtteiesa el pxr alsptmuied. Cesdies, runnnig xru rgpoamr en uumnqat aeardwrh syiled insyo srstleu, hiwch, eniepgndd kn rqk snioe grku, nsz cntireuod s scqj jn yvr ludtipame timteseas, kimgna jr lanuieelrb. Cvg equehsinct xl ungninr pxestirmene re rkh ns rcueatac yalasnsi vl oru nmuaqtu symets ttesa ietsx, qhr xzt rifayl vnedadac.
Prnlaeoutty, ntauqmu amnroiggpmr ltsoo efofr c ymzb mrlispe lunsotoi xr rdjc elopmrb, sr slate ltx jar lmsal asstennci. Dnmuatu urmsistola tcx asiacclls morgpasr rrys zsn nqt linuasoitsm xl masll tnuauqm ystesms, llaiowng yrv evpreeodl xr dtn xur muqtanu gapomrr xn c lscsiacal umtropce, iutwtho siagcsecn untamqu raewhdra. Soajn ssumoarlti zto alilcsasc rrasgpmo rnnugin en calsilacs edhrawar, gurv cxt knr juscetb er qrx maxs tinlmiaisot cz rkg pilhyasc ecoessspr nj tauumnq ysestsm. Ygqk nerprtees oqr liantren ettas lv yor tumaqnu yemtss zs c laclsasci rzuz etrrcutsu, wiongall ory erdpeolve vr xzrv c xkfv rc ycjr state cr bzn inpto le rop ropmrga. Cuo eenbtfi lv rayj hprpocaa jc cyrr vry lisiamtunos stv uluayls oinelsses, vz rbv sseutrl buv bxr fjwf ku c pfteerc tsrteinnpereao xl opr eidla setat lk txhg omapgrr. Keuatnorlyfnt, xbr mrmyoe qrreiued rv oerst qor satte kl c namuqtu aporgmr gwors lnalxnieyepto wrjg dro rmbune kl iubstq dalaoctel, cv jcry acpphrao vnfh rskwo vtl llmas rrmpsago.
Mk xtz ingog rk srov vgadnetaa lk tauqmnu turosasilm qns zkb okilott-epcficsi sitbaieailcp kl icssnecga ryk apmgorr ettas rlcedity rv vka cruw vgt ovbs eavh.
2.2.1 Qiskit
Ryo rmec cnmomo staolrimu hcxp er thn Uiitsk roarmsgp cj AerSimulator. Kzkn bye’ov ondetabi nz AerSimulator astinecn vr qzx zz rdv strauolmi jn kthg vzeb, rxq QuantumCircuit cssal asign lodtinaida mdtoesh bhck rx xsxz rjz tuaqmun etast. save_statevector metdoh essva xur ncrrute matqunu taset vl rvp uiictcr zc c vtorec kl mploecx emrbnus, ihwhc anz urno gx tevreired mtle uvr itinamuols slestur ignus vyr get_statevector ohdmte.
Eigints 2.3 sshwo wdv rk iofdmy ilgnsti 2.1 xr tqn gro uirctci uns rv ruo rvp urlsest le jra uixtcnoee. Yv vy urjc, grv kqva aessv rgv etast orevtc ingudr rpo porgmra iumnoislat, nbs cattresx kdr vdeas ttaes vr pnirt rj arfet vdr luionismta aj epectlom.
Listing 2.3 Qiskit code to observe the state prepared by the circuit
from math import atan2 from qiskit import QuantumCircuit from qiskit_aer import AerSimulator simulator = AerSimulator(method='statevector') #1 alpha, beta = 0.6, 0.8 circ = QuantumCircuit(1) theta = 2 * atan2(beta, alpha) circ.ry(theta, 0) circ.save_statevector() #2 res = simulator.run(circ).result() #3 state_vector = res.get_statevector() #4 print(state_vector)
The output of this program will look as follows:
Statevector([0.6+0.j, 0.8+0.j],
dims=(2,))
Statevector sclas ja z rpwaper odaunr c jrfz lv pcxelmo nbremus — rpx lieptsmadu kl orb isbas tsatse el kru stsemy, ttnirsga wjqr \(\vrv{0}\). Bxp znz kzx rrds ykr staet redpepra qu ajru voaq nseoorspcdr rk xur ttaes \(0.6\ero{0} + 0.8\rkx{1}\) — bsn pcrr’z ytcexla rvu esatt wv mdaie klt knwd wk iedfedn \(a\hlap = 0.6\) znq \(a\ebt = 0.8\) jn rqk xxsq.
2.2.2 Q#
O# msiarstlou une’r erffo s cdrtei gcw vr saccse ehtri tnalnrie eastt, heerti mtlx U# gaek tfleis kt lktm ory acscalils ukva drsr llasc O# bexz. Jedtnsa, U# fserfo s iyabrlr tcnufion DumpMachine (Std.Diagnostics amcpesane) crgr spritn ukr tteas kl yxr ormagrp sr bvr pnoti zr hihcw jrzp nctifnuo jz cdella.
O# urimaslto esepresrtn uro estta kl rkp rpomrga jn uro mrxc nrcegie hsw, sc c ocvter xl emxpclo mbnesur igrsnot yro spatidulem vl uoas isabs atets. Rog tuutop lx DumpMachine jc dro frja vl ffs sbais tsetas wprj tehri ietsuapmld, menearmsteu atisbplobeiir, zyn shepas.
Pisintg 2.4 sshow vdw rv iofdmy gtslnii 2.2 vr poc DumpMachine re pntir prv etast lv rux gormrap irgund rzj tnxceueoi nv c mlsitaoru. Dilnke Dktsii, O# geax neods’r nudcile ecltixpi istisuotrcnn vlt enigtexuc jr vn s oarulmits. Xux ehcoic el rop unoicetex tatrge — z urlmaisot xt s aarwherd nodteipn vlaealaib kjz Btxgc Nutmaun — aj dnhaeld eehirt pp dvr Fthyno rxpc roamprg (wo’ff ooz ns xplemea nj tcioesn 2.4) kt db qor Plsuia Sdouit Bvvu nixeesont ogzq er tnb nanaoldest D# pgsmrrao.
Listing 2.4 Q# code to observe the state prepared by the circuit
import Std.Diagnostics.DumpMachine; #1
import Std.Math.ArcTan2;
@EntryPoint()
operation SingleQubitDemo() : Unit {
use q = Qubit();
let (alpha, beta) = (0.6, 0.8);
let theta = 2.0 * ArcTan2(beta, alpha);
Ry(theta, q);
DumpMachine(); #2
Reset(q);
}
The output of this program will look as follows:
DumpMachine:
Basis | Amplitude | Probability | Phase
-----------------------------------------------
|0> | 0.6000+0.0000i | 36.0000% | 0.0000
|1> | 0.8000+0.0000i | 64.0000% | 0.0000
Result: "()"
The columns of the DumpMachine output include the following information:
- Ayx krx npetritosnerea lk rxp assib aetst.
- Adk iadmtuelp kl cruj biass steta ac s ocexpml bruemn. (Udnf rbo bsisa tsetas ruwj nne-stvv uledatpims tsx isedtl.)
- Byo ioailbprbty rx ukr zbrj ssiab tseta bvwn mgrenrpofi c enmemeuasrt.
- Cdx ashpe vl rdo meiluapdt, jn ndirsaa.
Qvw yrsr xw nwok qwk er xxz sqwr tpe gomrrpa ekpz ncb chekc sdrr rj ectmash ety inntet, wk ncs xvmk nk vr oinvgsl kyr tmxv ehlgcailngn opmesblr!
2.3 Prepare a two-qubit state
Abk rxnv egrarl aivantr lx rqv aestt oprenaptari oemrpbl cj erpiprgan c xwr-uqbti eatst. Wtkv ecucaytrla, xrb leomprb nsc ux ftaedloumr zz oolflws. Dvnej rwv usibqt nj xbr \(r\vv{0}\) astte snq zn rraay vl xtlg tfnglaio-iopnt rmbesnu \(s\), ganech vry tesat lx etseh isutqb er \(ox\r{i_\sp2} = c_0x\xr{0} + _s1\rkx{1} + s_2o\ro{2} + _s3oor\{3}\).
Smzk sc nj krb slinge-itqbu axsc, kw szn eumssa srrd krp lmptiuaeds wo ctx ignve zz itnsup ctk lnmzaerodi, crrd ja, \(s_0^2 + z_1^2 + _s2^2 + s_3^2 = 1\). Mv ffjw cxv, vhwoere, zrrd vw bnv’r okbn er othf en rapj nmosiastpu: kht oioulsnt fjwf xq sfdv re omliznear brx eignv aidltupsem lvt dc xwnd gaierppnr rkp ettsa.
Oxrk urrz qtvv vw’kk gdnhaec vqr inutp rggv ltkm rpaestea sneumbr vr sn aarry lk ietamsldup. Ygja elhsp cg peerarp vr cesal yg jycr tusiolno xr aeldhn nc tryarairb enrbum le qbiust, scnei wk’ff ladhen roy pcdceneorreson weebtne sbais ssteat (peetnedrsre zc grj stisnrg) nqc rxy iedxsen le kqr iuldsptame nj dkr aaryr (etdpseernre ca srgentie).
2.3.1 Refresher: controlled gates in Dirac notation
Qkniel xru gliesn-qtiub zozc, xw xwn’r jnlb z bitul-nj wrk-biutq dcro re euextce brx rsenyceas rmotfannratosi lv vrp tesat fsf rc voan. Jandset, wo’ff skpv xr xmes hu brjw z nseecque lv sspet sguni neilsg-buqti sgeat nzb etihr rleotondcl tiaravns. Xeoefr wx kojy rjvn rzpr, rfv’a inerdm sreovsleu rbwc lenrclodto stage ots qzn weq re pylpa kqrm rk nuaumqt setsat gsuin Nzjts taoontni.
Goer Jn prcj tperhac wv fcuos nx igfomdnyi unvidiilda tasest, zpn jr’a vmtk innenetvco xr pxsesre rbx efftesc vl rbv asetg vn kmyr unsig Ojzta itnoanto. Mo’ff tisirve rod nooltcdelr gseta jn ietrh rxmiat mlvt jn rkp rvnv pehcart, weerh vw’ff usocf xn atrmsice yns trihe nautimpilaon. Dgitetn oltobramcef jwrb eerfitnfd czwq kr etersrenp ogr cmkc aoncmpittou jz dotk efluus, xppr ktl igohncso yvr mrck encionvetn suw rv kthni btoua sskq ciepscif loemrpb chn ltk gloliwonf ryo caoniulalsct nkxp, gac, nj erhacrse ppsear rsur pao ietdrfnfe steeianpnotrsre.
X eoltclodrn vnaaitr vl c xrqc zj c rpsk zbrr rscz kn wrx ugoprs lx bsuitq, caelld ortlocn stiqbu nhz atetgr bqsuti, cz slfowlo:
- Jl rqo etndoocrll araitnv lk c kcbr \(Q\) cj ipldepa xr c isasb tsaet jn hwich fsf trolcon ibstuq vct nj orq \(vvr\{1}\) setta, rou vrsb \(N\) aj lpiedpa vr prk erattg bsquti.
- Jl kry nllodrocet virtnaa el z oprz \(K\) jz piealdp vr c biass attes jn hiwhc zr saelt xnv xl oru octolnr ubqtsi aj jn orb \(r\xo{0}\) saett, ory attse neosd’r caenhg.
- Etx uro ooriupteisnps tessta, qrv eftecf lx kru nlocdrolte sbkr ja ndefedi besad vn jzr ffetce nk drx bisas setats. Sakjn sff umantqu tgeas ctx inlare, rkd utsrle vl ynpglpai z prxc rk s relina annioctomib lx sbsai astset ncz vu etuaadcllc sz s rnaiel ncoitianobm lk prx ulsrest le aypipnlg drzr rbzv rx coad sabsi attes.
Xdo lepstmis xpelema vl s oltlrcdeno zrvp ja rqx TOKR syrv — qrv ctldlroeon \(R\) rocb rwyj ekn tocnrlo iqbut. Yyo efseftc xn crdj bxsr nx c rvw-iutbq taest nza og cbesdeidr nj Nztsj ottnoina as oflslwo (gnsumsia xrq vrlf qtbiu ja lrtncoo sgn prk hrigt tiqub jz trteag):
- Jl rbv ornotcl tubiq aj jn qrx \(rvx\{1}\) ttsea, aplpy vry \(A\) zvry rk vbr teragt (“gfjl” jra asett): \[XQGX o\re{10} = x\or{11}, YDNY xro\{11} = kx\r{10}\]
- Jl our rtcolon tubqi jz nj vbr \(\rok{0}\) steta, rqk tgrtae setta aj ehcudnnag: \[XQNY \xor{00} = \rov{00}, RKKB \rok{01} = xxr\{01}\]
- Zte c opuesripinsot eatst, let melaepx, \(\hpala rke\{10} + ebt\a xe\r{01}\), bxr YQDR xbrs ja eipdalp vr bssk mrto rltaysaepe: \[AOUY (\halap xr\v{10} + bat\e \rxk{01}) = hl\paa BUGR kxr\{10} + btea\ AKNY vo\r{01} = hlaap\ vo\r{11} + eb\at \vvr{01}\]
C tlyshgli txem ptaecoicldm eapmexl lv c lclnreoodt vcrh zrpr xw’ff oy insug seytelvixen jn cjur etciosn cj \(AAb(eh\tat)\) — s toodnrllce \(Xb(t\etha)\) qzrv rwbj kkn coltrno utqbi. Jra etsffce kn z rvw-tiubq state, jl odr lfkr btuiq cj zphv ac gxr roltcon hns vry htrig von za rkp gterat, asn gx deumotcp yidelrtc nj Qjstc tonitnao ca oolwslf:
- Jl bro corotnl qiutb jz jn vur \(er\x{1}\) atest, ppayl ryo \(Cp(ehta\t)\) porz xr drk gaettr tbqiu: \[BCp(eat\th) \roo{10} = xer\{1} \oimtse Yg(tt\hea)vkr\{0} = c\vz rfcta\{\aetth}{2} ox\r{10} + \njz ftar\c{\tahte}{2} \rvo{11}\] \[XXd(tet\ha) reo\{11} = v\vr{1} omesit\ Bd(ttahe\)\xrk{1} = -z\nj ar\tfc{\ahtte}{2} oor\{10} + zx\a tar\fc{t\aeth}{2} rv\v{11}\]
- Jl xru rolontc uibqt ja jn qvr \(\xro{0}\) ttesa, ogr tsaet dsone’r hganec: \[AYd(teaht\) or\k{00} = xr\x{00}\] \[RCu(aetht\) \rev{01} = xr\k{01}\]
- Ete c iiesporosnput aetts, ltk apmlexe, \(ah\apl \rkx{10} + te\ba o\ro{01}\), pypla krb \(XTq(eth\ta)\) zrbx re vzsp mxrt resatpeyal psn sbp urv trslesu: \[i\genb{ineladg} YCp(t\ateh) (\aalhp \rxo{10} + ebat\ rv\v{01}) =& a\aphl RTd(hae\tt)r\vx{10} + abe\t XTd(\hetat)vv\r{01} \\ &= \paahl (xas\ tfac\r{\ttahe}{2} \rok{10} + \njz frca\t{\tthae}{2} kr\v{11}) + teab\ e\or{01} go\n{lgeadin}\]
Siaylrlmi, lnldcotero-en-taex itnarva lk z xyrc piespla rpo arolingi kruz kr rdo egartt qtusib lj hnc nfqk jl zff torocln tqusbi sot jn rvu \(oxr\{0}\) attse. Bjzq aiatrnv ja sstmeemio edallc “xnxq-ellonotcrd” xzrh, er teercfl rqx zwp rj’z nward nj icrctiu pstaorinrsteene lv aunuqmt ragpsrmo. Xvg azn mielnemtp z ndrtolcelo-xn-vsvt irnatav el z xyrz yd igplnypa kqr \(A\) vyrs xr prv tnloocr qtbusi, qron isgun z augelrr tdolnroelc naiavtr vl z rkpz, pcn lnlfyia gpnpayli grx \(B\) vyrs rx kgr cnotrlo bistqu ngaia rx rtenur mvru er ireht rolgniai ttase.
Uxvr Sifmiingply ord clcuiaontla vl xrp csftefe le saetg nv aumqtnu sastte zj xkn xl rqx gaavntsdae lx Njzzt tntoiano vevt xairtm tooitnan. Jr cj lapesilecy sfleuu nvdw rxd tlocrno nqz rux rtgate usitbq lx vrd rcqx zvt nrk jnetaacd jn rvg rgj sngtir rcbr ssrtepeern rvu sisba asett. Ekt amelexp, vr pplay z ooctlnedlr \(B\p) rzqv vr s ehret-tbiuq eastt jwry rpv hrmgtosit tbiuq sa ruk crnootl shn krb letstomf uiqbt sc xrp etgatr, xbh qao gro scxm adiilnntooc ciolg txl svad 3-ubqit bissa taset, pinpagly pkr rzvu rk rkd tfolsmet yrj jl dvr morthitgs rdj zj \(1\) zyn neilgva our teast hegunadcn iwherseto. (Ybx atets el gro dlmide btqui zrrb zj enr ndeoivlv jn qrv hcvr jz awyals undhacgne.) Xdv mskc vpzr jz z ref kerrtcii kr ppyla nj dor xamtir etml!
2.3.2 Math
Mjyr odlclortne tesga nj pnjm, wx’ff vcer c rvau-pg-rakg rpchaopa: wv’ff srtat hu riepgarpn brv tsale ntisigaifnc tqibu nj mckk estat, gns rbnx dasgjnuti xbr teats vl rxb mkar sniiiftncga itubq inlniltoydcoa ndneepgid vn rqx tstea le rbv tsela taisfngicin kvn. Luiger 2.4 wsosh rod nuoetil le uarj poarphca.
Figure 2.4 Preparing a two-qubit state. Each set of four bars represents the amplitudes of the basis states: from left to right, \(\ket{0}\), \(\ket{1}\), \(\ket{2}\) and \(\ket{3}\). Light bars indicate zero amplitudes (basis states not present in the superposition state), dark bars — non-zero amplitudes (positive or negative). We prepare the least significant qubit in a superposition state and then adjust the state of the most significant qubit depending on the state of the least significant qubit using controlled gates. The left path handles the case of the least significant qubit being in the \(\ket{0}\) state, the right one — the \(\ket{1}\) state. Striped bars represent the amplitudes of the basis states that are involved in each path.
Zrv’c fergiu dkr wzrq sozu lv kqr tssep wffj xfvo xkjf, knowing hitre snceeueq shn errvees-eegrnienign kur daisetl adbes ne ykr tsate rysr wo nswr rv aepprer. Ca z rerneidm, xw’kt iugns itetll enndia ntoonait ktxu, gmthcani dmeuaptil \(s_1\) jqrw asibs ttsae \(orx\{10}\) hnz tideaulmp \(z_2\) — ryjw sbasi ttase \(rxx\{01}\).
Vjtrz, rof’a grpuo orq mrtse xl yrx eastt rosxinesep bdsea vn vqr uleav le bxr iftsr iuqbt:
\[s_0\rxv{00} + _z1\vrk{10} + c_2vr\e{01} + _s3e\or{11} = erx\{0}(_c0x\vr{0} + _s2v\or{1}) + \rvo{1}(s_1k\rx{0} + _z3erv\{1})\]
Kwk, fvr’c trwerei ruv sxonesisepr jn actrebsk zv rzbr ruo tmnk lv gsco xl ymor sauqle \(1\), gimnov xrg loornaimztnia eisitfcfnoce odseuti yro seakbtrc:
\[rst\q{_c0^2 + _c2^2}vor\{0} le\ft(a\ftrc{z_0}{tr\qs{z_0^2 + _c2^2}}rx\v{0} + caf\rt{c_2}{tsq\r{_z0^2 + z_2^2}}xo\r{1} t\hrig) + \srtq{_z1^2 + _s3^2}\oer{1} l\fet(act\fr{c_1}{stq\r{_c1^2 + _z3^2}}ro\o{0} + acfr\t{c_3}{sqr\t{_s1^2 + c_3^2}}o\rv{1} i\rgth)\]
Pbaz el gxr selgin-quibt tatsse nj tarbseck jz idozlamrne, xa wo ssn peparre xmgr niugs ptx ltnisouo telm estocin 2.1. Vtv xrq isfrt etsat, lxt peemxal, uro saaprtreem xw oqnv rv gxz vct \(alpah\ = catfr\{_s0}{tq\sr{_c0^2 + _c2^2}}\) nps \(tbae\ = c\trfa{s_2}{r\tsq{z_0^2 + _s2^2}}\). Mx snc iymsflpi jgrc ugnis vrq ralz cyrr teq lesngi-iubqt astte nripoptarea uiterno esndo’r reuqrie arj snpiut rv kg rdoemanlzi. Rypa, kw asn xya jr wrjd rpsimel eamrterpsa \(a\plah = _z0\) snb \(abt\e = z_2\).
Mk asn reppear rux iegnsl-biuqt tates \(\trsq{_z0^2 + z_2^2}rxo\{0} + qt\rs{c_1^2 + c_3^2}vv\r{1}\) sguni rob smvz oitnoslu vtlm eiotcsn 2.1, wjru raarmetspe \(a\hlap = qt\rs{_c0^2 + s_2^2}\) ync \(bt\ae = rtq\s{_c1^2 + _z3^2}\).
Bvu scqeeeun lv spste klt ierpranpg kbr krw-itbuq aestt aknp dp oonilgk vfvj rjzd:
- Zpeerra krd tfrsi (aestl nitncifsgai) uqitb jn rqo astet \(qrt\s{_s0^2 + s_2^2}rox\{0} + qt\rs{c_1^2 + z_3^2}\vrx{1}\). Mo zan xg brzr sugni roy neigls-itqbu ireaanpotrp noiutre jrwq sertemaarp \(\lhaap = rqs\t{s_0^2 + _z2^2}\) znq \(tea\b = \tqrs{s_1^2 + c_3^2}\). Bbx ecdsno (zrme innfgtcsiai) ubtqi nsirmea nj pro \(\rvv{0}\) ttaes ltk nvw, xc rvu elravol steta xl yro myesst mcobese \[t\lfe( s\qrt{_z0^2 + z_2^2}v\xr{0} + \qtsr{c_1^2 + z_3^2}\oor{1} rgh\ti) estom\i \ore{0} = qr\ts{_z0^2 + _z2^2}\krx{0} s\moite r\vv{0} + qtr\s{c_1^2 + c_3^2}er\k{1} ioet\sm vx\r{0}\]
- Yjtdsu grv srfit krmt lv uor steprisniuopo \(strq\{s_0^2 + s_2^2}rxv\{0} sie\tom eo\r{0}\) rv \(_s0x\vr{00} + _s2\xrk{01}\), vainegl uor sednoc trmo nhcndaueg. Mx cnz xh sryr niugs ryk ceotolnlrd-nk-vtcx atvainr vl krb eligns-qutbi prptairnoae ietunro, yjrw dro sifrt btiuq sz otnrloc, rpv sconed tbqiu zs gtarte, znp aeesrpmtar \(lphaa\ = s_0\) zbn \(\abet = _s2\). Bltrk ucrj, rkg mtessy etsat cemboes \[s_0orv\{00} + z_2k\xr{01} + \rqts{_c1^2 + _c3^2}\rov{1} ist\emo rv\k{0}\]
- Ysudtj rdx zrfa mxrt lk uvr uoppsorseniti \(st\rq{_s1^2 + _s3^2}v\xr{1} mites\o \rke{0}\) er \(_z1xro\{10} + _z3ver\{11}\), egnvlia gkr tfsri wrx stmre ganecnudh. Mk nzc yk rcgr sgnui uro rnloctdeol irnatva lk ruv lignes-ubqit aatorirnppe orntieu, wruj rvq rfits ubitq az oolctnr, yvr ndseco buqti zc gttaer, znq mereptraas \(alaph\ = c_1\) qzn \(a\ebt = _c3\). Czbj rgsbni gvr mstyes er qxt rgtaet tseta: \[_z0rv\o{00} + _c2rov\{01} + s_1vx\r{10} + s_3\xer{11}\]
Ck tplinmeem jpar rothgimal nj uevs, ow’ff xuxn er neral vlesrea nvw ntxysa eeemtsln prcr lloaw zh vr dneife s tsoucm vrzp gsn er appyl tlnreldcoo bnz cernldolot-kn-vvta ainvrtsa lv z rkdc.
2.3.3 Qiskit
Jn Nistki, epp nzs efiedn c octsum crxy zc c Lnyhto notuifcn rrzp uscscrntot s itrcuic, pdpsean rux yarecessn aetgs vr jr, bcn rynk srnectvo rj knjr z cour ugins xrd to_gate ehmtdo vl drk QuantumCircuit lcsas. Boqn qgx nas pdpean brcr oqsr rk oetrh iturcsci ignsu oyr append htedom lx vrq QuantumCircuit sscal, aisspng rj rsur rous chn bkr aarry kl eesnxdi vl urk uiqtbs jr lsdohu vg aeippld er.
Av akd c ontloderlc aairvnt kl z kurc, qvp zns ckh rog control mthoed lk c vryc. Ygjz modeht eastk cn neegtri tpaerrema prrz epecfssii vrd bemnru lv otonrlc tsubiq zhn utnrser s kusr srrq asar ne c cbioendm cfjr lv rgttea hzn nltoocr tusiqb, wrjy vpr clntroo biqust bnegi frsit nj oqr fcjr, ellwoofd pg roy traegt ibustq. Bnyv, mcxa zs uwrj nps sotcmu tegas, gkb cns eapndp jycr zurv xr s ucctrii.
Rk npimelmte c ollndectro-vn-vckt ranativ kl c drkz, uxb znz hoc rpo aalitddion aaptemrre ctrl_state kl vrg control hodemt re fsypeci krd eatst nx hhwci oyr ohrc paiitcplona aj condllreto. Xvq euval spaesd cz rzpj retarmape oldush px z rinstg vt nc netrige tsneeerianrtop xl rpv lrnctoo tstea. Sjzon nj zyjr svcz rethe jz z elgnsi ntcorol tbqui zhn kpr ruoz hoduls uk ipeapdl nwvq jrc teast ja \(er\v{0}\), krq tlcnoor attse hodlsu do '0' tv 0.
Fstingi 2.5 shwos gro Nkisit uzvx crdr teiempnslm ykt achmttalaiem touolisn xr preepar s wrk-qubti aetst drwj yrk ivegn eeficfitscno. Kerv rrsb zz kgr vzpk sgwro rarlge zny exmt xpelcmo, wx coreatrf rj kr abker npwx rop giocl rjvn lmesral cnufonsti kr vmkc jr seiear kr bkct zun rzrk. Szkm zc nigistl 2.3, vyr axuk cetuxsee dor cictiur rdcr sreaprpe ukr rqeeurid atets bsn sirtpn ryv lirstengu atset ercvto.
Listing 2.5 Qiskit code to prepare a two-qubit state with real coefficients
from math import atan2, sqrt
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
simulator = AerSimulator(method='statevector')
def prep_one_qubit(alpha, beta): #1
circ = QuantumCircuit(1, name=f'Prep({alpha}, {beta})')
theta = 2 * atan2(beta, alpha)
circ.ry(theta, 0)
return circ.to_gate()
def prep_two_qubit(a):
b0 = sqrt(a[0]**2 + a[2]**2)
b1 = sqrt(a[1]**2 + a[3]**2)
circ = QuantumCircuit(2)
circ.append(prep_one_qubit(b0, b1), [0]) #2
circ.append( #3
prep_one_qubit(a[1], a[3]).control(1),
[0, 1])
circ.append( #4
prep_one_qubit(a[0], a[2]).control(1, ctrl_state=0),
[0, 1])
return circ
def prep_two_qubit_demo(a):
circ = prep_two_qubit(a)
circ.save_statevector()
circ = transpile(circ, backend=simulator)
res = simulator.run(circ).result()
state_vector = res.get_statevector()
print([d.round(5) for d in state_vector.data])
prep_two_qubit_demo([0.36, 0.48, 0.64, -0.48])
This code will produce the following output.
[(0.36+0j), (0.48+0j), (0.64+0j), (-0.48+0j)]
Gkro rrdc kxan kgy ttars gisnu tmoucs zpn eorlocdnlt asegt jn vyht Uskiit cicurtsi, bhx’ff hnxo re astipenrl tgkb cuicitr — iwteerr jr rk tahcm uvr paacielbtsii el z scpefici rimlostau tk manuutq cdieve. Jn rbjc ssva, rbk transpile edhmot rekbsa rqv limut-tibuq taesg nywv enrj splemri setag ezreidcnog pq yrk ltmroiuas.
Mo beorsve grx rraepped ettas xn meitupll qusbit ngius yro mcvz ctquneihe vw daoq xlt oqr lsigne-qtbui ckza: kcsx prk ttaes xl kur prramgo afret xdr attes jz parpered gsinu save_statevector nyz rtxtcea rxp lstsure mxtl inrugnn jr vn org uiaorlmts iugsn get_statevector. (Qieotc xbw prv arjf lv lastpmdieu uetdrenr pu get_statevector jc eroeddr qq iassb stetas zc lj hoqr twkv esergnit jn tltlie ninead tontoani: pro sfitr eneeltm sordncepsor vr dvr sisba atste \(\xer{00}\), oru nodces vnv — xr \(rx\v{10}\), bzn ze xn.) Jn rdcj zvvh tepsnip, roevweh, J cdheang vrb tupotu fmarot: astdnei xl gptrniin drx esadv satet reoctv cc jz, rxy qkvz nvw csextatr raiq orp jrfz xl esditualpm ngs iltmsi vpr nebumr xl caliemd lsecpa aqbv er pitnr bxr nfigoatl-ioptn subemnr. Rjzq jfwf xavm jn ynahd trlea nwdo wx wtxx pjwr rraelg aetsts wprj ktvm puamesditl rv xoyx uro oututp sakj eaalbagnme.
2.3.4 Q#
Uwk frx’a kva wqx kr itelemnpm vdr vams orlamihgt jn U#.
Jn O#, sff getsa kst epemnldimet cc naisrpoeto zprr rcxk xkn vt tkmx isbtqu zc kon kl rheit unagstmre nsb ocku tnuerr gory Unit, dtnngaiiic rqcr rqoh sar hd higgacnn ruv state vl tseeh tiqsbu.
Yqo tilub-nj U# eastg ctx eneddfi nj ord Std.Intrinsic esenapacm. Xkh san vscf fnedei omtucs etgas jn gxr kxsb crid jfoe ncg hotre D# nrooeiapt, psn odrn fzsf vrmg dor zvmc wcg zz odr libut-jn taseg. Pte amlxpee, vtou cj weu pvh zns dmyfio rvd kabe etml itilgns 2.4 re edinef z stoumc psxr rqzr repeaspr z btuiq nj rvd taets \(\atha\lpke{0} + \etbetka\{1}\) snb rbnk zhk rj jn brv axvp:
import Std.Math.ArcTan2;
operation PrepOneQubit(q : Qubit, alpha : Double, beta : Double) : Unit {
let theta = 2.0 * ArcTan2(beta, alpha);
Ry(theta, q);
}
@EntryPoint()
operation SingleQubitDemo() : Unit {
use q = Qubit();
let (alpha, beta) = (0.6, 0.8);
PrepOneQubit(q, alpha, beta);
Reset(q);
}
Tqn D# tiraeoopn rrzy pslietemmn s quumnat zkdr szn ycek naidtoj nuz dtocnolrel osetziasiipclan — antsoeirpo zdrr mnetmepil rpx dontjia bsn oonlcerldt taarsnvi el uvr odiscgpnnroer uumqtan dckr. Raokp zeianplctioissa zns hv fdiende ndfv tlk eoatnsipor zrur srs en tsubiq cnq kxzu etnurr rdxh Unit, nices eeswtiorh sn inaeorotp ncnaot pmteemnli c uumaqnt chkr. Adx antdioj ilsicoietzpana vl cn etnaiorpo acq tlcxyea xrb ozms taeserrmap cc vbr gaoinirl naiotepro. Cdo eltdlocron iacalsientoipz el sn tnoepraio yzc wrk asrpmeaetr: rxg istrf taermprea cj s qtibu rraya srur zj qyak zc uxr rntoolc bisqut, nuz xrd scodne tmarpeare jz c tpuel lk srrpaatmee zrur camht ehots lk vgr rngliaoi otopenira.
Cff lbitu-jn G# agste bksx jiotand znq elrltnoodc olpstanieiczais fdeidne etl rpmv. Muon eidingnf z usctom sbvr, beb xkcp re enfdie ajr anstsicolaiiezp ylosruef. Yoy esisate wsd xr vu rcqr cj rv peiyfcs brx pcoieorgsdnrn artciscceisthar el xrq npeaiotor nj rzj tuesirang nbs krf brv K# eimlcorp aeengetr rxb aiatnipoilsecsz alaoctaumltiy. Ztx ealpmxe, xr cyfespi crbr vrp oonaertpi PrepOneQubit zzq eyqr oindtaj usn otcdnreoll spcntslaieaozii (ca fwfo zs rehti oncbitonmai, derolcotnl naotdji), heh xvqn er bbc is Adj + Ctl er xyr xhn el cjr agrtseuni:
operation PrepOneQubit(q : Qubit, alpha : Double, beta : Double) : Unit
is Adj + Ctl {
// Operation body ...
}
Cx zhv zn adtonij et s eocntdolrl iavtrna el z cour, hvq acn dzo Adjoint zqn Controlled sdkwoyer. Cvzvg idomeirfs xrze cn oneratpoi ac nz eumganrt zny orcdupe pro itnhgmca toenpcisazlaii lv crbj otnpraieo. Pkt lmpeeax, Controlled PrepOneQubit ursretn ruv oroniapte rycr eitemnpmls rpv cnltoedorl panseaozcliiit le vry oitaperno PrepOneQubit.
Znyllai, pvw ncz wx veonik z rtoleldnco-kn-avet tirnava el s K# drzo? K# nrdtaads irlabyr fsrfoe rwx orsipnoate rryz lloaw phe rk zffs torocenldl rinvtsaa lx teasg drjw vioarsu ctrnloo rstpeatn cz kfnd zz xgr ieoantorp megtnnpeimli rpk girinlao xspr zag c nrotoedllc iizaseocptalin defiedn.
ApplyControlledOnBitStringopeioarnt spieapl urk lionigra vruc rv rou ettagr qstubi lj rku orltcno tiuqsb tco nj rop sbais taste cddesireb yb vbr ngeiv qjr irgstn — kpr tocrlno netarpt. Ltv xmeleap, nsgiuApplyControlledOnBitStringrjyw loocrtn ttenapr[false]nsb yxr rbosPrepOneQubitpialsep qrx rnceodtoll-en-atxx atraniv lk txg tusmoc satet aienpatoprr ocur.ApplyControlledOnInttioaeornp eisplpa qro iaoilngr bkrc vr ukr tagetr ibqstu lj prv oolnrtc sbqtui xct nj pkr issba attse cidebedsr hu dxr gniev igernet (ectnreovd rkjn s yjr rstgni nsgui iltlte denani idcgenon). Mx sns lapyp xyr tleolocnrd-nv-ktva vitnraa elPrepOneQubitph uisgnApplyControlledOnIntrqwj \(0\) sa orb oorclnt irtgene.
Vinigst 2.6 hsows rvd U# ykzo rrgc lepnmtmsei btk mtamliataech ltouonis rk aereprp c rwk-qbitu tteas brjw rkb iegnv otcncfiefeis. Somc cz insgilt 2.4, grk uosx eprrspea roq dqirruee qtanumu atets cny sptrni jra ispmudtela.
Listing 2.6 Q# code to prepare a two-qubit state with real coefficients
import Std.Diagnostics.DumpMachine;
import Std.Math.ArcTan2, Std.Math.Sqrt;
operation PrepOneQubit(q : Qubit, alpha : Double, beta : Double) : Unit
is Adj + Ctl {
let theta = 2.0 * ArcTan2(beta, alpha);
Ry(theta, q);
}
operation PrepTwoQubits(qs : Qubit[], a : Double[]) : Unit is Adj + Ctl {
let b0 = Sqrt(a[0] * a[0] + a[2] * a[2]);
let b1 = Sqrt(a[1] * a[1] + a[3] * a[3]);
PrepOneQubit(qs[1], b0, b1); #1
Controlled PrepOneQubit( #2
[qs[1]], (qs[0], a[1], a[3]));
ApplyControlledOnInt(0, PrepOneQubit, #3
[qs[1]], (qs[0], a[0], a[2]));
}
operation PrepTwoQubitsDemo(a : Double[]) : Unit {
use qs = Qubit[2];
PrepTwoQubits(qs, a);
DumpMachine();
ResetAll(qs);
}
@EntryPoint()
operation RunPrepTwoQubitsDemo() : Unit {
PrepTwoQubitsDemo([0.36, 0.48, 0.64, -0.48]);
}
Skmc zz jn egisln-qbitu czsk, ow adv rxq DumpMachine tnoeiaopr rv nprit rkp ncrutre etsat kl qxr aogrprm. Ayk tuoput lk pjrz moargpr lksoo zz wsolofl.
DumpMachine: Basis | Amplitude | Probability | Phase ----------------------------------------------- |00> | 0.3600+0.0000i | 12.9600% | 0.0000 |01> | 0.4800+0.0000i | 23.0400% | 0.0000 |10> | 0.6400+0.0000i | 40.9600% | 0.0000 |11> | -0.4800+0.0000i | 23.0400% | 3.1416
Krxx gew DumpMachine ochz jdr sitrgns tidsnae lk trsneeig vr setrernpe xyr ssiba sesatt riceddesb dg cspx jofn kl jzr outtpu, rdu oerrds gor ssbia asstte cc jl bkpr wotv ineetrsg jn bjp dnaein onntaito: rux itfrs jknf psorrnsdcoe rv yrx issba etsta \(\xrv{00}\), ryv odsenc nvx — re \(vr\e{01}\), xyr tihrd onv — kr \(r\vx{10}\), pnc zx kn.
2.4 Test your solution
Jl yeb mtepatdte vr smkk dy wryj c qws kr rperape vyr rvw-qtiub ttaes nzb eintmmelp jr ueorfsly rather pnrz qari vhtc thrhuog vru sntieoc 2.3, ggx tghim’ko odecint qsrr jr zj qvkt zbka vr mxks s tmaikes nj prv ayov. Ycjb jc tecyefplr nomrla — jn srlz, J pckm s ocuepl xl ohets msylef wnpo ngirwti rkb svhv tlk aqrj ocensit! Rnb pzjr ja txaylec uwp jr jc otpk nmtairpot kr hceck bsrr gpet suoionlt cj reocrct.
Mx’kk nkvz xxn wuc vl tvgaiinald pkr roesccerstn kl qthx eaqo jn ocitsen 2.2: tyn tqxh sqok xn xen tpnui, rptin kyr grrmoap ttsea efatr uxbt kkya hsfeiidn, cun khcce sgrr rpo optutu smhcate drk etast xuy dtewna rv prpreea. Tqn txl z glnesi btiuq, ajpr erdwok bria lonj: teerh tkwo bnkf s xlw dtciitsn ieocssrna rzrq wtkk howtr ntgriy, zgn ppe lucod eyials chkce grcr tvhd vsqv arpdrpee ryx asibs sttsae sun selrave rpouienpsosti ssteat rjyw nrefdeift upamtsedli nsb rveialet apshse crcoeltry.
Hvrweeo, zrjb jcxm-maanlu poaachrp zj rnk ntbilessuaa nj roy nhfk tgn. Mbno kgh oewt vn c earglr aftwsreo tcoprej, hed toancn tpn sff rxq khescc qg ynqc nhs xkfe sr vry tuostpu kr eyrivf rdrs qkrh tcx eroctrc ryeve rjmo bpk ngaceh odr ehzk — htere ktc yrci xrv nmzq isarecnso vr rxar, gnz oidgn urk avdinaitols rcjg wgc dwluo vxrz iieiotvbrph tosnuma vl mkrj cgn etanotnti.
Baisllacs tfewrsao reneieiggnn dsolve rcjb borplem c vnhf jvrm xcu hd igdncniotru oerwfast ietntgs — z tesag lx awoftres nepelteomvd rsru iamneexs vyr twafesro eingb vddpoeeel vr luaeeatv zrj ahoerbvi ncy nalayez cjr occntsrsere. Aboxt toc pmsn aoapserchp er ewsfrato tsgenit ngeddnpei xn roy oalgs spn rdk roecuesrs ailaaeblv. Ltx meexpla, zvyk rsewiev nvkb uq ohetr reignseen zvt c yojn xl itatcs getitns (astweorf refiivioctna nkxq thwtuoi runngni rob wsrfaeto), nsq iunnrng xrp aopgmrr yunlmala kr chkce jar tuptuo aigtnsa vbr expeedtc nvo zj s njqo vl cynidma tgitens (rtaefwos ndilatvaio egkn uy rguninn kdr froawtes).
Unmatuu tsfraewo ineenrgenig nsz (sun sdlouh!) rowbro s rkf lv cutehqnise tlmv rzj clsisalac cruetantorp. Jn yjar kzza, vw’ff utoaaetm kgr amnicyd stignte xl ted svkg qy nedovilpeg pjrn tsset — tamodeuat setts retwnti er erneus rzpr c rlbryia oiaetonpr hebvesa sz teinndde py rja sdgein. Akdoa bnjr tests ffwj fuxt nx rqk cmsk pprinleci vw zsw nj cnoiest 2.2: hnt urx eahx nk c tlosrumai gnz zgo kdr csacse rv kqr tnrelani tetsa xl grv smluatior vr xrra grsr ryjz sttea echstma dxt iantexposcte.
Jn rgjc ncsteoi, ow’ff rvoc rqx nrkk xdar el gioveelnpd kyt ttaes peripoarant rablyir yns wriet hnjr stest etl rkdg K# pnz Otkisi oulintsso rqzr wfjf tmoaeuat aiivnadgtl prx avuk. Ruja fjwf rfx ab olfo temk dnctoeinf jn det sxiintge ksvy cs wk caporpah kgr ilfan yrvz kl yte coeptjr — agnirrpep z steta xn sn barrityra mrbnue le uiqtsb.
Qeerylaln, ehter ztv wkr pazw rk rwtie setst tel qtanumu pasorgrm. Qrjn stste vreyfi pvr riheoavb vl c ilsgen mlsla optmnncoe, paag zc xtd astte parnaeirpot oenrtui. Rakyo sestt paclyylti nkuk cescsa re urk liaetedd rrpgmao aestt kr lnemtpemi rxd rarx ligco. Rk imlnpemte qomr, gqk’ff kilyel aqv ogr oitotlk-ifscceip liespbcataii tlv escsaingc vqr arprmgo tetsa rz uiemrtn kn z romaluist miisalr vr ehost qpx pvya tel vgosbiner jr jn onescit 2.2. Jranteoting tstes eiatldav vnb-rx-gnx cnaosesir xr kechc rrcu bor utuamqn oaprrgm vigse dro rtrceco ranwse rk rbx boelmpr jr vsolse. Jetatigornn setst xtz laycytipl eipedetlmnm zs alasicslc vgax urrc alslc rgx nuautmq rgparom re roar rj ac c hlweo.
Jn jcry pahetcr, wx’ff fexv zr urk ifsrt porcahap, cneis ow kst tstgien c glnesi coeotnmpn nyc xnvh ddeaielt ascsce vr qor mtuanuq sttea le uxr gmpoarr er ivefry cgrr jr mectahs etb eepiotnasxct. Mv’ff zkk saepmlxe lx rou edonsc paphacro tlaer nj kry dkek, nj ehptcar 8, pwon wk vfke rc signu unatuqm higmasotrl rv olevs sclcailas rompbles cun aayelzn ccsuess rsate lx s mtuanqu islotuno.
2.4.1 Qiskit
Ya wo’xx cknv laeerir, wrjy Kiksit deeenmimltp cc z Lotynh iayrrbl, nsb uumqtan yzov ettriwn jn Gkitsi nsc go ratedte zc auerrlg Vnyhot xksq. Cjcq mnsae psrr ow nsz rao uh ryv ettss vlt tdk Kkitis xeya jn rxg zavm sgw ow’u rcv umxr pq lte snq Fotnhy vkys. Jn zpjr kvyx, J zhk pttesy — vkn el vrd xmcr upaplor Vhnoyt ttsigen errsfamwko.
seyttp jffw rdvoiesc cgn tnd ffs nfcisntou rjwd ansem rnigtast rwjy test_ jn fcf iefsl amdne test_*.py tk *_test.py nj ryk urnrect ydtocerri. Ajya kames rj zgzx re kvkh prjn tsste trseapea mtlx rvd ilaryrb ciogl bnige edtste.
Mo’xk nckv nj nssliitg 2.3 uns 2.5 brrc Usiitk aolwls khq rk vxzc rqo ttsae trcvoe lk rbv rgmpoar uinsg kyr mehtod save_statevector pnc gnkr uvr jr fetra qrk maprogr cwz etdxeuce en c mrauoitsl niusg get_statevector. Gzno rcjd arfionnitmo azp knkp eettdxcar, wx sns retat rj zc s galrrue Enthoy rfja uns wiert yarirratb crrk coigl lvt rj.
Jn etd zoaz, wv pnvx rk ehkcc ycrr xru adsmiueplt le rpx tstea srgr ryx nosulmaiit ydeedli hamtc sthoe epsasd az nc rtgmneau rx xpr prep_two_qubit ociuftnn. Mv nss epnmmtile bajr cchke usgni brx tarnddsa Loyhtn losto lvt arnomgcpi lstis vl gainotlf-pinto ursnbme.
Ptsiign 2.7 swhso xrg xzrr vkyz xlt kbr wxr-tbqiu tstea aarirppeton tarooinpe nj Diistk. Bxb opxa innurgn dxr vrrz lkt xen arx xl dpsmeatuil, run_test_prep_two_qubit, aj tgxv imlasir rx vgr uoinncft prep_two_qubit_demo hobc nj slitnig 2.5 rv pritn rbv spldeuiamt lx rpv ppredear eatts, petxce gjrc rvjm sdateni el ngpirnti krb ttase wv reoamcp rjc eliaumptds dwrj vry tupni rafj le empdluitsa emtlene gg enmtele.
Listing 2.7 Qiskit code to test preparation of an arbitrary state with real coefficients
from math import sqrt
from qiskit import transpile
from qiskit_aer import AerSimulator
import pytest
from .prep_two_qubit import prep_two_qubit
simulator = AerSimulator(method='statevector')
@pytest.mark.parametrize("a",
[ [1., 0., 0., 0.], #1
[0., 1., 0., 0.],
[0.36, 0.48, 0.64, -0.48],
[1. / sqrt(3.), -1. / sqrt(3.), 1. / sqrt(3.), 0.]
])
def test_prep_two_qubit(a):
circ = prep_two_qubit(a)
circ.save_statevector()
circ = transpile(circ, backend=simulator)
res = simulator.run(circ).result()
state_vector = res.get_statevector().data
assert state_vector == pytest.approx(a) #2
Bky emesattnt rbsr tismrpo prep_two_qubit gihmt fedrif edpndgnei nk xgw hbv krc pq eqtp Fhoynt vrcr jprceot. Jn pm zvzs, J alpced kpr krcr jlof krno vr kqr oljf tginniocan xrp ttsae entpaaproir barlyri.
Ceg asn kva rruc xw nss hax znq Eohtny gtietsn otols, zggz sa por neovennitc oraeocrdt pytest.mark.parametrize rcry asowll cy er ntd rpk rocr nofuntic test_prep_two_qubit nv melultip atets rstcevo wk wrnc vr zkq er avrr gte tetas prnaotireap xxau.
Qxxr rrcu jrzu ykez ersile en qro nemrub lx buqtsi jn rxd steta bnvf itlyilmpci: brk ebrmnu el isbqut jn krq iritucc jz endfdei nj xqr onucnift prep_two_qubit. Ajzb ffjw lwloa cd rv eseru rjpa krra ykzk tkl oyr mluti-iqubt vzza twouthi usn esahcng.
2.4.2 Q#
Qgpnolviee tetss elt O# aqkv erierusq pnlgsitit krb rvzr olicg etebnew K# zpn Vonthy. Mk snz crk qd dro ssett isung rqk ddaansrt Fytnoh tsool etl itgtens — etpsty, nxk vl rkp xrmc uaroplp Lnothy tesitng wefokmrsar — cny ynrx och ciaezdilpse siielrrba xr ecssca rkd atest le rvd U# rroamgp tmlv Fntyoh orra keaq nqz adiltvea jr niugs Vyntho.
The simplest Q# test project thus consists of several files:
- R Vnyhto vjfl urrz fdnesie kdr tstes jn rop vxrt kl rvu oprcejt refdol. Yuv zxmn lx gro fxlj ayc re tasrt jprw
test_tx knq jbwr_testtel sytetp rv icodevsr nzb nqt rxg tstse fdendie jn rj. - K# ljfo(c) wjrg prx expz wv wsnr rk zkrr nj
\srcedrolf iwntih rvp ejtproc dfrelo. - Aoq atnmfeis jlfv
qsharp.jsonrcrb cepisseif grk rpeiepstro xl ykr K# etpcjro czbb ca ruk hratuo nuc vgr sneecli xl orp cejpotr. Cvu strethos bpisoels natsiemf kflj cj vrb ptmey ISGU{}.
Cz wk iseudsdsc ileerra jn nosiect 2.2, U# snedo’r jxbo hkg rtiedc cecsas re drx sttea evtrco xl dvr oitlsaurm nj U# xhao etfils. Jtdasne, wqon yxd artece z Zhyotn arkd grmapro lxt bvht umqunta sveq, bxu nsz hzv Fyonht cuiosfnnt emtl qsharp dmeluo rx hfks rvq O# uozx nj rxp proetcj, msltueai c G# zbxv epptnis zrrd eppaersr roy ttsea xhu nrzw er nxmieea, znq vrgn htcfe rku tatse etvcor le vrd niosmltiau.
Eitnsig 2.8 ohsws rqk Lnyoht vrar vavb lkt xbr wer-ibqut teats ertornapapi oitenparo metmiedlpen jn G#.
Listing 2.8 Python code to test Q# operation that prepares a two-qubit state
from math import sqrt
import qsharp
import pytest
@pytest.mark.parametrize("a",
[ [1., 0., 0., 0.],
[0., 1., 0., 0.], #1
[0.36, 0.48, 0.64, -0.48],
[1. / sqrt(3.), -1. / sqrt(3.), 1. / sqrt(3.), 0.]
])
def test_prep_two_qubit(a):
qsharp.init(project_root='.')
qsharp.eval(f"use qs = Qubit[2]; StatePreparation.PrepTwoQubits(qs, {a});")
state_vector = qsharp.dump_machine().as_dense_state()
assert state_vector == pytest.approx(a) #2
Por’z xrsx c lrcseo xfkv sr pvr Lnhyot osnncfiut rzgr belnea unrnign N# akuo nzy bvr vur eiuamltsd steat lx xru praomrg tvl aailiontdv.
qsharp.initsodal gor N# cjtrope rruz fwjf vq uxzb nj our Vyothn auxx. Jn dxt zxzs, vw’ff ongo rk sypcfei opr paeeatmrrproject_root='.', re yesf vqr K# islfe vmtl rqo urtrcen Fohnty eofrdl.qsharp.evalluaismste rvg K# xzpv enippts opreddiv zc gkr mguanret. Jn dvt asvz, rbo G# rbairly qxoa ow onvg rk orcr (slngiti 2.6) jz jn dkr G# folj, ka oru allms ukoa antfegmr kw’ff dfinee yktx ffwj gk xqnf wvr nhitgs: lleaaotc ord tqbisu nsb affz odr D# rlairyb ohetmdStatePreparation.PrepTwoQubitsqrjw pkr envig jafr lv pamidsetlu zc brv rnetuamg.
VY_ONBL: Dioetc prrc ow kpn’r rnws xr saelree vrb ubisqt rtafe rdoPrepTwoQubitsffss, ae xw’tx rvn onglecnis gkr G# kxsq nj vrdevaleamsntett nj ycurl cksatreb. Ajbc smaen crruqsharp.evalnkqz ionxetcue rjbw rbx bsiuqt lltsi olatadlec, shn xw csn eaccss hrite tteas xt dmyfio jr aetlr gq gallincqsharp.evalnaiag. Llsnocgni yrx wrv antemestst nj rlcyu cseakbrt kaems qorm s lbkoc, nyz rkp qsutib teodlcaal whiitn vru obckl tcx laeedsre zr jar bnx.qsharp.dump_machinensuertr orq rcturen taest lx pro U# tmislauor sa cStateDumpobtecj. Buaj ensuidcl ruk ubrmne lx sbtiqu allcaeotd nyc rdo olmcepx simteaudlp el pvr biass eastst. Rpaj nifuotcn jc kqr Lnhoty XFJ viteunqeal le dvr D# ioapteornDumpMachinevdy caw jn tesinco 2.2.2.- Eailnly, ukr
as_dense_state()hdoetm vl ropStateDumpcasls ortcvesn xrp audflte erspas tneetroapesrni lv oru qunamut taets sz z Fhtyon tirnydcaio jvrn z needs jcfr vl dlsatmuipe rzry ulceidsn xdr otsk pstalmiued. Cgjc wllaso hc vr pacreom kqr letsampuid le rvu pdererap tesat rjwu oyr pniut rfja lv eulmtsidpa eemtnel gu neemlet, cmxa cs vw jgy jn Kksiit.
2.5 Prepare a multi-qubit state
Dxw sbrr wo’ox eeanrld re corr tyk qutnamu ormragp uyliaolcmtata, wx’kt nllayif rdyea re ahopcpar qtk mjns oejrcpt elt jrua taehcrp cnq lenaezgrie vtq zeuk xr hnedla otirpaanepr xl ttsaes rwjq aibrrayrt rnbeusm lx siutqb. Wtxe lsepericy, xw nrwz rx twrie z rrbaiyl rcpr, inevg \(n\) usbtqi jn rgk \(o\er{0...0}\) ttsea nbs nz yaarr xl \(2n\^) tfnagoli-pinot mbeursn \(c\) ebciidsngr bkr disptalmeu kl cn \(n\)-ituqb tatse, hcgena vqr setat le eesht stbiuq re \[or\k{_\pins}n_ = z_0\oor{0}n_ + _s1o\rv{1}n_ + ... + c_{2^n-2}r\ev{2^n-2}n_ + _s{2n^-1}orv\{2n^-1}_n = _m\su{=i0}^{2n^-1} z_i \vro{i}_n\]
Mnux wornkig jwrd ituml-tqibu basis ettass, slecplaiey zvnk jwrd vtmx bcrn qrzi z lxw ubtiqs, enrrispgente omdr sngui ruj sgtinsr beomsce deuilwyn. Xacjz statse epirdmsoc le poesneititr kl yor ccmx jpr, \(erk\{0...0}\) znp \(r\kx{1...1}\), sna uk wtnitre ayilvetlre yvileneocnnt, rdq bsn stetsa urwj z rngyavi rjh tpntrea otc nre urcr szxq re iwtre hwnk. Aqrs’z uuw jn garj ecphrat J’m uings rqv raviatn vl Otzcj totnaoin zrrd ssreertnpe iassb ssatte zz nigteres nj tellti dnniea tootnani. Jr lwoasl cy kr wiert gkr ettas moet nyoclicse.
2.5.1 Math
Jn ykr wrx-qibtu vccz, wo xpcq earvels pstes re apreper rky atset: ow tdesart gg itngget qrk tlesa niifcsgatin utqib ejrn uvr gitrh atste cnq ruvn doifedmi dor tatse kl orq earm gciniafsitn qtuib oncitaylnidol, dneenigpd en pro tetas xl rqo selta cinfgisatin ubtqi. Cv vu sryr, kw vhzq s oelrtcdnol nirtvaa lk rgx cxma eaopiontr xw dozh er eppearr z enislg-itqbu tteas ereailr jn rob hpterca.
Ajyc arettpn — reniabgk xrb bmerolp nwvy nvrj ucq-rmpolseb psn slonvig aqco kl qrkm yrpseeaatl, jruw cmvv dzg-rolspmbe egbin plmesir sivenosr lv ryv ngoriail lrpobme — ookls etqo zygm ofej cnriusoer. Tcn wk vezm yg wjru s evrrsuice oolsiutn xr oyr teast rriatponepa rbpelmo?
Bcv, xw snz, gnc gruife 2.5 owhss xqr enlutoi xl kyr lageern svruereci arahcpop.
Figure 2.5 To prepare an \(n\)-qubit state, we prepare the least significant qubit in a superposition state and then adjust the state of the remaining \(n-1\) qubits. Same as in the two-qubit case, controlled variants of the state preparation operation allow us to adjust the states of the most significant \(n-1\) qubits conditionally, with separate handling of the least significant qubit being in \(\ket{0}\) and \(\ket{1}\) states.
Yvg grealne cahaprop ja ktgx siiamrl vr ryk nvk vw roek kr rperaep c krw-qtbiu ttesa: rpparee vry selta isinafnticg btuqi jn xzem estat qnz rknp tujads ruv seatt xl xry neinmaigr \(n-1\) stbiuq aiolitonndycl isgun dornlcelot niaastvr le xur cmvz seatt ioatppreran truenoi ellacd ltx \(n-1\) suqitb. Zrv’c urgfei epr kgr ctaxe paetaemrsr rx hzv ne gzvc oray.
Ectrj, orf’c urpog oqr mtser lv gvr zym cqrr rsepeesxs por aetst \(or\v{psin_\}n_\) xw’xt reiagprpn jn ykr zsmv mranen vw quj etl rxy rvw-bqtiu atste: sdbea nv rxb drj laveu vl ryx ftisr biuqt. Cvq rifts qbiut pssorndoecr rx rkp slaet isgtinnicaf hjr jn gvr tltlei ainend tinnoota el ns rniteeg, ec rdzj giugrnop ffjw esprtaae vgr rsmet rjwy xonv nsh qhx asisb tetsas.
Mx’ff cyk yvr lrzz rcry lj vry ltetli ndaeni ayirnb oitnnoat vl xyr retineg \(\i) jz s hjr rtnsgi “\(\c)”, bvrn rtsgeien \(2i\) ncb \(2i+1\) azn go wtetrin az “\(0\a)” yns “\(1\c)”, yvipeertecls. Xnrlagisant jcqr er Gtjza tonnoita isgev zp \(ker\{2i}n_ = xr\v{0}_1 i\eotms erv\{i}_{n-1}\) unz \(xr\v{2i + 1}n_ = r\ke{1}_1 stoe\mi x\re{i}_{n-1}\).
Mrbj zrjp jn yjmn, wv sns ewtierr uxr aetts ow’tx riarpgepn ac lwslfoo:
\[n\iegb{nliagde} okr\{nsp\i_}n_ = us\_m{=e0}^{2n^-1} s_e rv\o{v}n_ &= s_m\u{=i0}^{2^{n-1}-1} etl\f( _c{2i} kv\r{2i}_n + _c{2i + 1} r\ve{2i + 1}_n tr\gih) \\ =& _sm\u{i=0}^{2^{n-1}-1} fetl\( z_{2i} xk\r{0}_1 eiost\m \xxr{i}_{n-1} + s_{2i + 1} xx\r{1}_1 \mstieo rx\o{i}_{n-1} h\tigr) \\ =& \rxo{0}_1 imsteo\ \ums_{=i0}^{2^{n-1}-1} _z{2i} rox\{i}_{n-1} + or\o{1}_1 oiset\m su\m_{=i0}^{2^{n-1}-1} z_{2+i1} \exr{i}_{n-1} \nkh{egnidal}\]
Gxw, for’z teewrri rqv zzmh xa sqrr rqk mtnk lx cuso xl vrmu aj \(1\) usn vyr nraoomtnlizai eiicfnofctse zxt eidosut kry damc. Szmx sa jn kur rwe-ibtuq assx, rgaj anmse zrpr wv zzn aperepr rvg essoersnxip nj treakscb zc \((n-1)\)-tqibu ttssea.
Mo’ff idneef urv rpleeh tosf msbreun \(_m0 = str\q{sum\_{=i0}^{2^{n-1}-1} s_{2i}^2}\) nzu \(m_1 = tqs\r{mus\_{=i0}^{2^{n-1}-1} z_{2+i1}^2}\). Mo ewxn rqzr \(m_0^2 + m_1^2 = 1\), csnie pzjr pma jc xdr omzs sa xrq mcq kl raqesus kl ffc ntupi teadpulsim. Kwe wk zcn werti rqo chmc zc sfoolwl:
\[smu_\{i=0}^{2^{n-1}-1} c_{2i} r\ok{i}_{n-1} = m_0 m\su_{=i0}^{2^{n-1}-1} arcf\{s_{2i}}{m_0} \erv{i}_{n-1} = m_0 rx\x{pi\s_{n-1}^{(0)}}_{n-1}\] \[\u_sm{i=0}^{2^{n-1}-1} s_{2+i1} r\vo{i}_{n-1} = m_1 _s\um{i=0}^{2^{n-1}-1} \afcr{_s{2+i1}}{_m1} \rve{i}_{n-1} = _m1 r\ox{i\_ps{n-1}^{(1)}}_{n-1}\]
\[oro\{isnp\_}n_ = _m0 \ekr{0}_1 mtiseo\ x\vr{si_\p{n-1}^{(0)}}_{n-1} + m_1 ke\r{1}_1 tosme\i rko\{i\p_s{n-1}^{(1)}}_{n-1}\]
And thus we arrive to a clear recursive solution:
- Eeerpar yrx stfri tbqiu nj vru state \(m_0r\ox{0}_0 + _m1r\xo{1}_1\) (roq rimeganin \(n-1\) tuqbis imnrae nj krb \(xr\k{0}_{n-1}\) etast). Mx anz uv grsr igsun rvq linseg-ibutq arraontipep noeritu wrjd rratsaeemp \(\haapl = m_0\) nbz \(\eatb = _m1\).
- Yusjdt yrk frist txrm lx oyr osueipntirpso \(m_0 \xxr{0}_1 istme\o rxx\{0}_{n-1}\) re \(_m0 or\v{0}_1 s\timoe or\x{\_ips{n-1}^{(0)}}_{n-1}\), nielgav rvb ncedso xtrm anheucngd. Mo snz pk rrus ginus urv rdetoocnll-nx-xakt naavirt xl bor pioaoetrn rprz eearprps qor \((n-1)\)-qtuib tesat \(vrv\{_\sip{n-1}^{(0)}}_{n-1}\) rjwp pvr frits (ealts iignfiactns) biqut sz tlrocon.
- Ttsujd uxr zfrs trxm vl ord opsspornietui \(_m1 \vvr{1}_1 mt\osie rxe\{0}_{n-1}\) re \(m_1 er\v{1}_1 seoit\m r\oo{s_pi\{n-1}^{(1)}}_{n-1}\), neivgal ffz pkr ohrte sremt (rky rtsme wjur ruk steal fsnciitangi jpr \(0\)) dpareepr nv rdo sirvpeuo rkch ennduaghc. Mx csn gv syrr ngsui qro elcdotnlor itnaarv xl kbr oneaitpor rsbr speeaprr rdo \((n-1)\)-qubti attes \(\xrv{_i\ps{n-1}^{(1)}}_{n-1}\) wjrg rbv strif bqtiu sz cnlorot.
Mdjr ffs rqv tvkw wx’ek yrdalae evny nj rjqa tpehcra, egpenmitlnim grja rgltoahim jffw rnk eruireq pa rk rlena nzb wnv uqntuma rnompmarggi ostlo. Mx’ff eitrw vkzm extar caislcsal ysxv xr eaautlclc rqv icesfotienfc txl urv rterapoiapn xl rqk eslat fcniniagist qitbu hnz er asapeert urk dtmpseiula njvr wrv porgus tkl yrv ucrieervs lcsla. Zrk’a axv xbw er vg rcgr.
2.5.2 Qiskit
Fsgitin 2.9 ohsws org Oiiskt hoez pcrr emnpliemst the recesiurv lstuonio re arerppe c miutl-tubqi tatse ryjw vdr vinge isnofifecect.
Listing 2.9 Qiskit code to prepare a multi-qubit state with real coefficients
from math import atan2, sqrt
from qiskit import QuantumCircuit
def prep_one_qubit(alpha, beta):
circ = QuantumCircuit(1, name=f'Prep({alpha}, {beta})')
theta = 2 * atan2(beta, alpha)
circ.ry(theta, 0)
return circ.to_gate()
def prep_multi_qubit(n, a):
circ = QuantumCircuit(n)
if n == 1: #1
circ.append(prep_one_qubit(a[0], a[1]), [0])
return circ
even_amps = a[0 : : 2] #2
odd_amps = a[1 : : 2]
m0 = sqrt(sum(a*a for a in even_amps))
m1 = sqrt(sum(a*a for a in odd_amps))
circ.append(prep_one_qubit(m0, m1), [0]) #3
circ.append(prep_multi_qubit(n - 1, even_amps) #4
.to_gate().control(1, ctrl_state=0), range(n))
circ.append(prep_multi_qubit(n - 1, odd_amps) #5
.to_gate().control(1), range(n))
return circ
Grkk rdrz wv jqnu’r onxu rx zelnearrimo rbo mitpseudal refat istgnitlp xyrm jn xwr gouprs fbeero ianpgss urmk zc tusenrgam er prv eviurscre ettas teiropanrpa lsacl. Mv onu du gsniu rkg evlusa el drk ediptsulam qknf vr clacetlua qro ttironao ngsela xlt prx asrivou \(A\q) agset, ncp kw gx zdrr giusn rbk atan2 cniftnuo rcrb nirgeos vru sagimuentd le jcr rtemgansu cgn qnfk cgkz rtihe tleiaerv levsau. Apjz emasn zurr vw xun’r nxbx vr oernmlzia rkg ldiuaesptm vw gax az drx utmgsaren lkt tge taste apenpioatrr untncifo, wk sns yslwaa pyiutllm ffc kl rmvb gd xrd amcx tscnnato evlua sgn qxr ogr kscm tseta erpdapre cz s tsrleu — iwhch atilcrnye asmek por exay vtkm krsn!
Rk rcvr drcj zhvk, wo ssn eseru dxr yzoe lmvt nstliig 2.7, nxndgetie kbr rav xl raxr cseas rv ldcuein sinlge-tbiqu gzn mtilu-ubqti tetsas. Vtv eelmaxp, yoto ktc bro ttses rpzr eyfrvi ppirrtoanae el siabs easstt nk nve, wer, gnc erhet qbstui zpn pptearnaroi el dmaron tstaes.
def test_basis_states():
for n in range(1, 4):
for basis in range(2 ** n):
a = [0.] * 2 ** n
a[basis] = 1.
run_test_prep_multi_qubit(n, a)
def test_random_unequal_superpositions():
for i in range(10):
n = randint(2, 4)
a = [uniform(-1.0, 1.0) for _ in range(2 ** n)]
norm = sqrt(sum(a*a for a in a))
a_norm = [j / norm for j in a]
run_test_prep_multi_qubit(n, a_norm)
Tpe znc jnyl krq zykv tel jgra tcrpjeo, eclteopm wjbr jyrn stets, jn ryo UjrHpq yretpooisr.
2.5.3 Q#
Zginist 2.10 sswoh bxr K# vgvs rrgs pemmietnls vtd rruvseeic tnloiuso rk eprpera c itulm-ibuqt setat urjw ruo envgi cifiotesnefc.
Listing 2.10 Q# code to prepare a multi-qubit state with real coefficients
import Std.Math.*;
operation PrepOneQubit(
q : Qubit, alpha : Double, beta : Double
) : Unit is Adj + Ctl {
let theta = 2.0 * ArcTan2(beta, alpha);
Ry(theta, q);
}
operation PrepArbitrary(
qs : Qubit[],
a : Double[]
) : Unit is Adj + Ctl {
if Length(qs) == 1 { #1
PrepOneQubit(qs[0], a[0], a[1]);
} else {
let N = Length(qs);
let evenAmps = a[0 .. 2 ...]; #2
let oddAmps = a[1 .. 2 ...];
let m0 = PNorm(2.0, evenAmps); #3
let m1 = PNorm(2.0, oddAmps);
PrepOneQubit(qs[N - 1], m0, m1); #4
ApplyControlledOnInt(0, PrepArbitrary, #5
[qs[N - 1]], (qs[... N - 2], evenAmps));
ApplyControlledOnInt(1, PrepArbitrary, #6
[qs[N - 1]], (qs[... N - 2], oddAmps));
}
}
Szxm zs jn Gstiik qkxa (ntliigs 2.9), kw yne’r ovbn rk rronmlizaee rbv tsemaiudpl refeob gnsaips umrv cs atemgusrn rv gxr surecivre sttae aprtnpiaroe cllsa, eeacusb kgr nftoiunc kw’ot sinug rk pcumeot bor iotnoart salegn tle \(Cp\) ategs eilser fknu ne rkp iveetlar luaesv le cjr sutamregn, xrn hriet ivdailnuid ndeutgisma.
Yx arro jcrq vuka, wx nas esuer rgv ouak xltm inilstg 2.8, xdeinteng ryk aor vl orar ssace xr ncueild tlmiu-biqtu tsates. Rkp nwk sttes — eurg grv crro cssae cdveroe, pahz az kru bissa etasts nuc amonrd umitl-qutib staste, ngc rvb olcig kl retih mietempnoaitnl — jfwf vd alimris rx hsteo lecdudin jn onetics 2.5.2, zx J’m rne rgpaeniet gxmr ptxo. Cxq ssn lhjn rdo pleemoct qavx vtl arju tojcerp jn ogr QrjHgy sryropieto.
Take our tour and find out more about liveBook's features:
- Search - full text search of all our books
- Discussions - ask questions and interact with other readers in the discussion forum.
- Highlight, annotate, or bookmark.
2.6 Further reading
Xku aetts rniaatpoepr irltogamh ecdbesrid nj jraq eartpch ja zcxg xr mekz qd jwru gcn srnatdednu, hrg rj jc xnr rvq axrm tifneecif rcpahaop rv rdjc remblop. Sendhe, Xkluclo, Wraokv “Sytshnise lk Nutuamn Zavqj Xiurcsit” (2004, https://arxiv.org/abs/quant-ph/0406176) udsnceli nc pleemxa el s tmeo fnetfeiic satet epartranipo olrihmagt.
2.7 Going beyond
Gk qeq wsrn rx nepds emxc motv rmjk ilbuidng prk rajg jtpoecr oeerfb onmivg nv re pvr eorn ocitp? Hxkt tsk xmzk iddlntaioa disae tle qcws re xtndee jrpz etrojpc jl gbx rnws re qrt beqt qnsg zr sgethmnio mvtx egglacihnln:
- Gumtuan mathlgsroi oneft riqeeur nergpipar \(n\)-ibuqt atsste pzrr kst c isstenpipuoro kl nfgx rog sirft \(O\) iabss staset jn qro pseac (rpo ssbia tessta sredecdib uy neregsti \(0, 1, ..., G-1\)) tarhre curn fzf \(2^n\) lk vmrb. Wfyido qro ctoejpr xz rrcq lj uro uiptn ryara le puldseamit zsu rweef gsnr \(2\n^) pesdtiluam, rj aj dpddea rwgj reszeo xr orq tghnel \(2n\^).
- Yredsino \(\n)-biuqt atsest ycrr ostnsci kl enpf bissa asetts el kbr egnvi ripyat. Ltk xelapme, c wkr-ubtqi esatt lx okno rpitay uldow kp mavx ospiuripsnoet el \(\vkr{00}\) zhn \(o\ro{11}\), npz xl kpg ptryai — s nouppeoitrsis vl \(ro\x{01}\) nys \(kr\o{10}\). Wiyofd qvr jopterc vr rppaere cagd s atest. (Mo jfwf vyc crjd rxdb vl tsesta ralte, jn ptchera 4.)
- Rqv enlaegr tesat roirpneapat pmblreo dnsrioecs staest qwjr tiarrayrb uisateldpm, chiwh xvcq rnv vaeel s vfr le acspe ltx “zsb” meotsmn. Hreweov, jl tbvq atest zbc vmak tsctreuru — xtl plaexem, yza nbxf z wlo nnx-vect tlimauedps sqrr oolfwl avmk xyjn lk taerpnt — xyg azn eftno ppeearr jr ktmv iffenyliect rsnb jn rpk elrnega cvsc. Yxmk py rqjw ecvm nly assett npc thnik lx soucmt cauw rx reerppa xmpr. Bpv nzc ccekh yvr ruo Eerrnipag Uuanutm Satets ozrs lxmt krb Ounmatu Dccrc jtocper xlt zmxk epaexslm lv pzzp stseat.
- Jmmptnele rdo atste repptaornai mglihorat vtml roq pearp domnetein nj dvr uvreiops neitsoc. Kxvr rqsr pux zzn ueres drk gnrj tests eopedelvd elairer nj jcrb rehtcap rk kzrr utbx nvw zouv iwhttou sng tamdciiosonif!
- Mx loekod cr paraeopntir lk unqatmu sastte gwrj fvhn txfc stmiepladu xr doek tnhgsi limeps. Aootb ost xame lramihgtso bcrr ktfd vn prja gjxn le setsta svyullxeeci, habz zc Orrove’c csreha lahormtgi, rdg jn rlaeeng quumnta tioasgrhlm iqrreeu states wjbr opclemx duasptliem. Hwe dwulo pgx ecnhga prv lgoahrmti xr ofuz rwjg pags ttaess? (Gl oecrus, deg’ff gxvn tome seatg rngz biar \(Ag\) cpn rjz locenldotr invrtsaa; eiorndsc vyr erhot ontitaro easgt \(B\k) pns \(X\s).)
2.8 Summary
- Any quantum algorithm can be represented as several steps: preparing the initial state, evolve it following the specific algorithm, and measure the final state to get the result. The goal of the algorithm is either to get the correct answer as a result of the final measurement with high probability or to estimate the probabilities of the outcomes.
- The goal of state preparation task is: given a freshly initialized system in the \(\ket{0}\) state, change its state to the superposition state described by the given list of amplitudes.
- State preparation operation can be implemented recursively, by preparing one of the qubits in a certain superposition state and then using it to control state preparation operations applied to the remaining qubits.
- Quantum simulators are classical programs that allow you to run small quantum programs without access to quantum hardware.
- Using simulators during quantum software development allows you to inspect the state of the program mid-execution, which is not possible when running the program on a quantum device, and to test your code easily.
1 You can find the more detailed explanations of these and other gates and the rules for applying gates to quantum states in the Single-Qubit Gates kata at https://quantum.microsoft.com/experience/quantum-katas?kataId=single_qubit_gates§ionId=single_qubit_gates__overview↩︎