Paano i-program ang isang computer ng kabuuan - Bahagi 2

Mga laban na may mga sukat ng dami

IBM Research https://www.flickr.com/photos/ibm_research_zurich/33072160062/

Ang artikulong ito ay may 'Bahagi 2' sa pamagat para sa mabuting dahilan. Nagkaroon ng isang Bahagi 1, kung saan tiningnan namin ang batayan ng pagsulat at pagpapatakbo ng mga programa sa kabuuan.

Ipapalagay ko na basahin mo ang hindi bababa sa unang kalahati ng iyon bago darating.

Karamihan sa mga aktwal na kaalaman sa coding na kailangan mo para sa tutorial na ito ay nasakup sa huling oras. Ang artikulong ito ay nakatuon sa ilan sa mga bagay na magagawa natin sa mga utos na ito.

Paano tumingin sa mga qubits

Sa mga programa mayroon kaming mga variable. Sa ilang sandali kakailanganin nating tingnan ang mga ito.

Ito ay maaaring sa dulo ng programa kapag nakuha namin ang resulta. Maaari rin ito sa panahon ng programa, kapag ginagamit natin ang variable bilang bahagi ng isang kondisyon na pahayag. Alinmang paraan, marami itong nangyayari. At kapag ang mga variable na di-dami ng mga variable, ito ay isang medyo hindi mapapansin na proseso.

Ito ay dahil ang mga variable na hindi quantum ay may tiyak na mga halaga. Ang pagtingin sa kanila ay nagsasabi lamang sa amin, o sa iba pang mga bahagi ng programa, kung ano ang halaga. Walang tungkol sa variable mismo ang magbabago.

Hindi ito totoo sa mga variable na dami, na maaaring magkaroon ng mga hindi tiyak na halaga. Maaari silang maging isang tinatawag na superposition ng kabuuan, na hinahayaan silang hawakan nang maramihang mga magkakasalungat na halaga nang sabay-sabay.

Kung titingnan natin ang mga ito, kailangan nilang isuko ang lahat ng kakaibang kakaibang ito. Pinipilit silang kumuha ng isang tiyak na halaga, at pagkatapos ay sabihin sa amin kung ano ang kahalagahan na iyon. Dahil ito ay hindi lamang isang proseso ng pasibo, kailangan itong maingat na pagsasaalang-alang. At nangangailangan ito ng isang pangalan. Tinatawag namin itong pagsukat.

Sa artikulong ito ay tuklasin namin ang ilan sa mga katangian ng pagsukat. Gagamitin din namin ito bilang batayan ng isang mekaniko ng laro, at makita nang eksakto kung paano i-program ito sa isang computer na kabuuan. Sa huli magkakaroon kami ng isang bagong bersyon ng Battleships.

Pagma-map sa mundo ng isang qubit

Bago tayo magsimula sa pagsukat ng mga qubits, dapat nating subukang maunawaan ang kanilang mundo nang kaunti. Ang pinakamahusay na paraan upang mailarawan ang isang qubit ay ang paggamit ng isang globo. Ang anumang posibleng estado ng qubit ay tumutugma sa isang punto sa ibabaw ng globo na ito.

Ang mga estado 0 at 1 ay ganap na naiiba, ganap na hindi nababagabag. Sila ang magkasalungat sa bawat isa. Kaya nga sila ay mabubuhay sa kabaligtaran ng panig. Karaniwan kaming pipiliang maglagay 0 sa north post at 1 sa timog.

Pumili tayo ng isang punto na pantay-pantay sa pagitan ng dalawa, sa isang lugar kasama ang ekwador. Maaari itong maging saanman gusto mo. Tatawagin namin ito +. Bakit +? Bakit hindi?

Ang + estado ay mayroon ding kabaligtaran, na naiiba mula dito bilang 0 ay mula sa 1. Ito ay nakatira sa kabaligtaran, na magiging isang puntong kasama ng ekwador. Tatawagan namin ang estado na ito -.

Sa mga puntos 0, 1, + at - ngayon na tinukoy, isa pang pares ng mga puntos ay humihingi ng pansin sa amin. Ito ang mga pantay-pantay sa pagitan ng 0 at 1, at pantay-pantay din sa pagitan ng + at -. Tatawagin natin itong mga ↻ at ↺. Bakit? Dahil nakita ko minsan ang isang tao na hindi sumulat ng Da Vinci Code na ginagawa ito, at nagustuhan ko ito.

Na-mapa namin ngayon ang mundo ng qubit na may anim na puntos. Ang mga ito ay hindi nangangahulugang ang tanging magagamit namin. Ang mga ito ay mga landmark lamang kung saan kami ay mag-navigate.

Pagsukat ng isang qubit

Ang anumang pagsukat ay sa amin ay humihiling ng isang qubit na pumili sa pagitan ng dalawang magkasalungat na puntos sa globo.

Ang klasikal na halimbawa ay para sa aming paboritong pares ng kabaligtaran na estado: 0 at 1. Hinihiling namin sa qubit na pumili sa pagitan ng dalawa. Kung ito ay nasa estado 0, pupunta ito para sa 0. Ang isang qubit sa estado 1 ay magkatulad na magbibigay ng resulta 1. Para sa anumang iba pang estado, ang kinahinatnan ay magiging random, na may pinakamalapit na pagpipilian na pinaka malamang.

Sa ekwador, ito ay 50/50 na pagkakataon alinman sa paraan. Kaya kung ang ating estado ay + o -, at tatanungin namin kung ito ay 0 o 1, kakailanganin itong pumili ng isa o iba pa na may pantay na posibilidad.

Ang pagsukat batay sa 0 at 1 ay may ilang mga pangalan. Maaari naming tawagan itong pagsukat 0/1, para sa mga halatang kadahilanan. Tinatawag din itong pagsukat sa batayang Z, dahil sa espesyal na relasyon na ang mga estado 0 at 1 ay may operasyon na tinatawag na z. Marami pa sa kwentong iyon sa ibang oras.

Ang susunod na pinakasikat na uri ng pagsukat ay ang isa para sa + at -. Tatawagan ko itong pagsukat na +/-, ngunit maaari mo ring makita itong tinatawag na pagsukat ng batayan ng X. Gumagana ito sa parehong paraan tulad ng dati, ngunit para lamang sa + at - sa halip na 0 at 1. Kaya kung magsimula ka sa isang qubit sa estado + at gawin ang pagsukat na ito, makakakuha ka ng resulta +. Ngunit kung magsimula ka sa 0 at magtanong ng parehong katanungan, pipiliin ito nang sapalaran.

Mayroon din kaming isang pagsukat para sa mga kakaibang arrow na bagay. Ito ay tinatawag na pagsukat ng batayan ng Y. Walang sinuman ang may sukat na sukat ng Y.

Medyo kaunti lang, kahit na ang dami

Ang pagsukat ng mga di-dami na bagay ay isang proseso ng pasibo. Sinasabi sa iyo kung ano ang ginagawa ng bagay, ngunit hindi ito binabago sa anumang paraan. Ang pagsukat ng mga bagay na dami ay ibang-iba. Ang mga sukat ng dami ay hindi lamang nagbabago ng aming kaalaman tungkol sa mga variable. Binago nila ang mga variable sa kanilang sarili.

Ipagpalagay na mayroon kang isang qubit sa estado +, at pagkatapos ay tanungin ito kung ito ay 0 o 1. Kapag binibigyan ka nito ng isang random na resulta, hindi ka lamang pinupukaw. Hindi ito sinasabi sa iyo ng ilang mga katarantaduhan dahil tinanong mo ang maling tanong. Sa sandaling bibigyan ka nito ng isang resulta, mananatili ito. Magbabago ang halaga upang maipakita ang sagot. Kung sasabihin sa iyo 0, ito ay 0 magpakailanman (o hanggang sa muling gulo mo ito, hindi bababa sa). Makalimutan na ito ay kailanman +.

Nangangahulugan ito na ang isang qubit ay maaari lamang siguraduhin na ang resulta nito sa isang solong pagsukat. Kung alam kung sigurado kung ito ay 0 o 1, ito ay ganap na hindi sigurado kung ito ay + o -, at ganap ding hindi sigurado kung ito ay ↻ o ↺. Ang isang qubit lamang ay may isang limitadong halaga ng katiyakan na lumibot, limitado ng kawalang-katiyakan na prinsipyo ni Heisenberg.

Nangangahulugan ito na nakakakuha lamang kami ng isang pagbaril sa pagkuha ng impormasyon mula sa isang qubit. Sa sandaling makuha namin ang isang solong resulta ng binary, lahat ng alam ng qubit bago alam ang pagsukat ay nakalimutan. Naaalala lang nito ang resulta na ibinigay sa amin. At sa gayon, sa kabila ng walang hanggan bilang ng mga posibleng estado ng qubit, maaari lamang nating kunin ang isang solong impormasyon. Iyon ang dahilan kung bakit namin iniisip ito bilang ang bersyon ng quantum ng kaunti, sa halip na isang quantum float o quantum 3 vector, atbp.

Ang mekaniko ng laro

Gagawa kami ng isang pagkakaiba-iba ng Battleship kung saan magkakaroon ng dalawang uri ng pag-atake: mga bomba at torpedo. Isang matagumpay na pag-atake ang kinakailangan upang malunod ang isang barko, ngunit ang pagkuha ng isang matagumpay na pag-atake ay hindi palaging madali. Ang ilang mga barko ay may napakalaking pagtatanggol laban sa sasakyang panghimpapawid na walang bomba na lalapit sa kanila. Ang iba ay mahusay sa pag-aalis ng mga torpedo.

Upang maipatupad ito sa isang normal na computer, maaari naming tukuyin ang dalawang variable ng boolean para sa bawat barko. Sasabihin sa atin ng isa kung immune ang mga bomba, at ang iba pa para sa mga torpedo. Maaari itong suriin sa panahon ng pag-atake upang makita kung lumubog ang barko o hindi.

Kung ito ang pagpapatupad na ginagamit namin, magiging teoretikal na posible para sa isang barko na maging immune sa parehong uri ng pag-atake. Ito ay magiging mahirap na disenyo ng laro, dahil ginagawang imposible para sa isang manlalaro na manalo. Ang isang mabuting pagpapatupad ay kailangang maiwasan upang magkaroon ng anumang hindi masisira na mga barko.

Ang isang paraan upang maiwasan ang paggawa ng naturang mga barko ay may ilang simpleng mga linya ng code. Hindi iyon ang aming estilo, bagaman. Sa halip, ayusin namin ito gamit ang mga mekanika ng quantum!

Partikular, susubukan naming pisilin ang dalawang boolean na ito sa isang solong qubit. Dahil hindi sila magkasya, makakakuha kami ng ilang mga kagiliw-giliw na pag-uugali ng kabuuan. Ito ay magdagdag ng ilang mga kagiliw-giliw na gameplay sa laro, pati na rin ang pag-iwas sa anumang barko mula sa pagiging hindi masisira.

Ipapatupad namin ito sa pamamagitan ng pag-uugnay sa isang pag-atake ng bomba sa isang pagsukat 0/1. Kung makuha natin ang resulta 1, sinabi namin na lumubog ang barko. Para sa 0 ibinabawas namin na ang barko ay immune sa pag-atake ng bomba. Para sa mga torpedo ay sa halip ay gumagawa kami ng isang +/- pagsukat, na may - nagpapahiwatig ng pagkawasak at + nagpapahiwatig ng kaligtasan sa sakit.

Ang pamamaraang ito ay ginagawang imposible para sa isang barko na talagang maging immune sa parehong uri ng pag-atake. Kung nalaman natin na ang isang barko ng kaaway ay immune sa mga bomba (ibig sabihin, ang estado nito ay 0), alam namin na dapat itong ganap na hindi sigurado tungkol sa mga torpedo (ang kinalabasan ng isang +/- pagsukat). Dahil ang isang pag-atake ng bomba ay tiyak na mabibigo, samakatuwid ay dapat nating atake sa mga torpedo sa susunod.

Ito ay maaaring pagkatapos ay lumiliko na ang pag-atake ng torpedo ay nabigo (ang estado ay nagiging + pagkatapos ng +/- pagsukat). Ang barko ay magpapasya na tiyak na immune sa kanila, at ang anumang karagdagang pag-atake sa torpedo ay mabibigo. Ngunit ang lahat ng pag-asa ay hindi mawawala. Sa pamamagitan ng pagiging tiyak tungkol sa mga torpedo, hindi ito sigurado tungkol sa mga bomba. Ang pag-atake sa kanila sa susunod (paggawa ng isang 0/1 pagsukat) ay maaaring humantong sa tagumpay.

Kung ang pag-atake ng bomba ay hindi magtagumpay, bumalik tayo sa mga torpedo, at iba pa. Ang pinakamahusay na taktika ay upang patuloy na lumipat sa pagitan ng dalawa hanggang sa tuluyang lumubog ang barko.

Sisimulan namin ang mga barko bilang hindi sigurado tungkol sa kanilang kaligtasan sa sakit sa parehong pag-atake. Maaari itong gawin sa pamamagitan ng pagsisimula ng qubit sa isa sa mga batayan ng Y. Hayaan ang para sa ↻. Ito ay talagang isang estado na nakilala natin sa Bahagi 1, lalo na u3 (0.5 * pi, 0,0) 0, kaya alam na natin kung paano ito gagawin.

Pagharap sa qubits na maiksi

Ang pagpapatupad ng laro sa isang processor ng quantum ay hindi magiging madali hangga't maaari nating asahan. Titingnan namin ang lahat ng mga problema na makukuha sa aming paraan, at makita kung paano makakapaligid sa kanila.

Ipagpalagay na ang isang barko ay inaatake ng isang bomba at nakaligtas. Pagkatapos sa susunod na pag-ikot ay natamaan ito ng isang torpedo.

Kung ang laro ay pinapatakbo sa isang normal na computer, at ginagaya gamit ang normal na mga bit, ang pagpapatupad nito ay magiging tuwid. Ang barko ay masisimulan kapag nagsisimula ang laro, at pagkatapos ay maghintay sa paligid ng memorya hanggang sa magpasya ang player kung ano ang gagawin dito. Kapag ang manlalaro ay nagpapadala ng isang bomba, ang mga kaukulang operasyon ay ilalapat upang makita kung nawasak ito. Kung makaligtas, naghihintay ulit muli hanggang sa susunod na pag-atake.

Hindi ito gagana para sa amin. Ang Qubits ay hindi maaaring umupo sa paghihintay para sa mga humancales. Ang ilang mga segundo ay higit pa sa sapat na oras upang sila ay mag-crash at magsunog, hindi bababa sa kasalukuyang teknolohiya.

Ang kahalili ay upang magpatakbo ng isang bagong proseso ng kabuuan sa tuwing nagagawa ang isang pag-atake. Ang unang trabaho ay masisimulan sa estado ng estado, upang ang mga resulta ay magiging random para sa parehong isang 0/1 pagsukat (pag-atake sa bomba) o isang +/- pagsukat (atake sa torpedo). Ang resulta ng pagsukat ay pagkatapos ay naitala at nakaimbak sa memorya sa normal na computer. Kapag nangyari ang susunod na pag-atake, isa pang trabaho ang nilikha upang makita kung ano ang mangyayari. Ito ay masisimulan sa resulta ng huling pagsukat, at sa gayon ito ay nagpapatuloy.

Ang paggawa ng isang pagsukat +/-

Sa ngayon nakasulat ako ng isang buong pagkarga ng mga salita, ngunit hindi isang solong linya ng code. Magsimula tayo sa pamamagitan ng pag-alaala kung paano ipinatupad ang isang pagsukat ng 0/1 sa QASM code.

sukatin ang q [0] -> c [0];

Ang papel ng c [0] dito mahalaga na muling bisitahin. Ito ang output ng proseso ng pagsukat. Ito ay ang normal na bit kung saan ang resulta ng pagsukat ay nakaimbak. Para sa isang 0/1 pagsukat ang resulta ay 0 o 1.

Lahat ito ay medyo prangka para sa isang 0/1 pagsukat. Ngunit ito ay +/- mga sukat na tinitingnan natin ngayon. Paano natin mailalabas ang impormasyon sa isa sa mga ito?

Nais pa naming iimbak ang resulta sa isang normal na bit c [0]. Dahil ito ay isang normal na bit, wala itong kaalaman sa mga kakaibang estado + at -. Alam lamang nito ang normal na binary. Samakatuwid pinili naming iulat ang resulta + bilang c [0] = 0, at - bilang c [0] = 1. Ang katotohanan na ang mga ito ay magiging kapareho ng mga resulta ng isang 0/1 pagsukat ay hindi magiging problema. Tulad ng sa anumang programa sa computer, dapat nating malaman kung ano ang na-program, at sa gayon dapat nating malaman kung paano bigyang-kahulugan ang mga resulta.

Ngayon alam namin kung paano makuha ang mga resulta mula sa isang pagsukat +/-. Ngunit hindi pa namin nalaman kung paano aktwal na gawin ang isa. Ito ay dahil kailangan nating maging sneaky tungkol dito. Kailangan nating i-hack ang proseso na gumagawa ng 0/1 mga pagsukat at ginawa itong isang +/- isa sa halip.

Ang susi sa aming hack ay isang operasyon na tinatawag na Hadamard. Ang paglalapat nito sa isang qubit q [0] sa QASM code ay ganito ang hitsura.

hq [0];

Ang utos na ginagamit namin sa Python upang magdagdag ng linyang ito sa isang file na QASM na tinatawag na gridScript ay

gridScript.h (q [0])

Ang epekto ng Hadamard ay upang magpalit ng Z batayan na nakasaad sa mga X na batayan at kabaligtaran. Ito ay isang pag-ikot ng Sphere na gumagalaw sa isang qubit estado 0 sa isang +, at + sa 0. Katulad nito, ang 1 ay pinaikot sa - at kabaligtaran.

Nangangahulugan ito na ang kuwentong maaari nating sabihin tungkol sa isang qubit sa mga tuntunin ng 0 at 1 bago ang Hadamard, dapat nating sabihin sa + at - pagkatapos nito. At ang anumang kwento ng + at - ay nagiging isa sa 0 at 1.

Ito mismo ang kailangan natin. Ito ay nangangahulugang ang isang pagsukat sa isang +/- pagsukat sa isang qubit q [0] ay maaaring gawin sa pamamagitan ng sumusunod na QASM code.

hq [0]; sukatin ang q [0] -> c [0]; hq [0];

Upang makita kung bakit ito gumagana, dumaan tayo ng ilang mga halimbawa. Ang qubit q [0] ay magsisimula nang sariwang ipinahayag sa bawat isa, at sa gayo’y magiging sa default na paunang halaga ng 0.

Halimbawa ng Zero:

sukatin ang q [0] -> c [0];

Ang qubit ay nagsisimula sa estado 0. Tatanungin kung ito ay 0 o 1 at sinabi sa c [0] ang sagot. Ang resulta ay palaging c [0] = 0.

Halimbawa Isa:

xq [0];
sukatin ang q [0] -> c [0];

Ang qubit ay nagsisimula sa estado 0 at pagkatapos ay maiikot sa 1. Ito ay tatanungin kung ito ay 0 o 1. Ito ay laging sumasagot sa 1.

Halimbawa +:

hq [0];
sukatin ang q [0] -> c [0];

Ang qubit ay nagsisimula sa estado 0 at agad na mapihit sa +. Pagkatapos ay tatanungin kung ang estado nito ay 0 o 1. Ito ay random na pumili ng isa o sa iba pa, at ang estado nito ay na-update gamit ang sagot.

Ngayon nakagawa kami ng ilang mga walang kuwentang halimbawa, gumawa tayo ng isang bagay na mas kumplikado.

Halimbawa ++:

hq [0];
hq [0]; sukatin ang q [0] -> c [0]; hq [0];

Ang qubit ay nagsisimula sa estado 0 at pagkatapos ay maiikot sa +. Pagkatapos nito, mayroong dalawang katumbas na paraan upang maipagpapatuloy natin ang kuwento.

Ang isa ay sasabihin na ang tatlong pangwakas na linya na kolektibong gumawa ng isang +/- pagsukat. Hiniling nila sa qubit kung ito ay + o -. Para sa + ibabalik nila ang resulta c [0] = 0, at para sa - bumalik sila c [0] = 1. Dahil ang qubit ay pumapasok sa pagsukat na may estado + sa halimbawang ito, palaging sinusukat ito bilang isang +. Samakatuwid ito ay lumabas sa pagsukat na nasa estado pa rin.

Para sa iba pang kwento tinitingnan namin ang mga epekto ng mga linya nang paisa-isa. Ang pangalawang Hadamard ay tatanggalin ang epekto ng una, at sa gayon ay umiikot ang qubit pabalik sa estado 0. Pagkatapos ay tatanungin kung ang estado nito ay 0 o 1, at sa gayon ay laging sumasagot 0. Ang isang karagdagang Hadamard ay pinihit muli sa +.

Ang parehong mga kuwento ay sumasang-ayon sa mga nakikitang epekto. Sumasang-ayon sila na ang output c [0] ay palaging magiging 0, at sumasang-ayon sila na ang estado ng qubit sa dulo ay magiging +. Hindi sila sang-ayon kung paano ito nangyari. Parehong may bisa ang parehong interpretasyon.

Kung nais mo ang ilang mga jargon upang maghanap ng mga bagay sa Wikipedia, ito ang mga halimbawa ng Schrödinger at Heisenberg na mga larawan ng mekanika ng kabuuan.

Halimbawa +1:

xq [0];
hq [0]; sukatin ang q [0] -> c [0]; hq [0];

Narito ang isa pang halimbawa kung saan mayroon tayong dalawang katumbas na kwento. Maaari nating sabihin na ang q [0] ay nagsisimula nang 0 at pagkatapos ay maiikot sa 1. Ito ay pagkatapos ay paikutin t0 - bago dumaan sa isang 0/1 pagsukat. Ito ay sapalarang nagpapasya sa isa o sa iba pa, ay nagbibigay ng output c [0] = 0 o c [0] = 1 at naaangkop ang estado nito. Kung napagpasyahan ito 0, ang panghuling Hadamard ay pinaikot ito sa +. Kung hindi man ito magtatapos bilang -.

Bilang kahalili maaari nating sabihin na pagkatapos ng pag-ikot sa 1, ang qubit ay dumaan sa isang pagsukat +/-. Ganap na nagpapasya sa pagitan ng dalawang mga pagpipilian na ito, na nagbibigay ng output c [0] = 0 para sa + at c [0] = 0 para sa -. Nai-update nang naaayon ang estado, nagtatapos sa alinman sa estado + o -.

Muli, ang dalawang kuwentong ito ay pantay na may bisa at sumasang-ayon sa lahat ng mga napapansin na epekto. Kung nais nating isipin ang tatlong linya

hq [0]; sukatin ang q [0] -> c [0]; hq [0];

bilang isang pagsukat +/, malaya nating gawin ito. Kung nais nating isipin ito bilang isang Hadamard na sinusundan ng pagsukat ng 0/1 na sinusundan ng isang Hadamard, mabuti din iyon.

Mayroong isang mahalagang bagay na dapat tandaan bago tayo magpatuloy. Ang kasalukuyang API ng IBM ay hindi namin hinahayaan na gawin ang anumang bagay sa isang qubit matapos namin itong sukatin. Ito ay hindi isang pangkalahatang tuntunin para sa mga computer na kabuuan. Karaniwan ay inaasahan naming magagawang mapanatili ang pagsukat at pagmamanipula ng mga qubits hangga't nais namin. Ngunit hindi natin ito magagawa.

Hindi ito nagdulot sa amin ng anumang mga problema. Dahil ang mga qubits ay hindi maaaring umupo habang ang mga manlalaro ay gumawa ng mga pagpipilian, mayroon na tayong ganap na muling likhain ang estado pagkatapos ng bawat pag-ikot ng pagsukat. Ang pangalawang Hadamard ay epektibong magbukas sa susunod na trabaho, na kumikilos sa reincarnated na bersyon ng estado.

Ang lahat ng iba pang posibleng mga pagsukat ay maaaring makamit ng mga katulad na mga hack. Kailangan lang nating gawin ang ilang mga operasyon bago maipalabas ang aming alternatibong pagsukat, at pagkatapos (kung pinahihintulutan ng API) na gawin ang mga kabaligtaran na operasyon pagkatapos lamang.

Pagharap sa mga pagkakamali

Ang kasalukuyang teknolohiya ng quantum ay hindi perpekto. Ang mga qubits ay hindi palaging ginagawa kung ano ang nararapat. Kung 0 ang iyong qubit at gumawa ka ng isang 0/1 pagsukat, ang resulta ay dapat palaging 0. Laging. Ngunit sa kasalukuyang mga aparato ng kabuuan, mayroong isang pagkakataon na ito ay 1. Maaaring ito ay dahil sa isang operasyon ng x na pumutok habang hindi kami naghahanap. Maaaring ito ay dahil sa pagsukat ay namamalagi sa amin. Ang mga kaganapang tulad nito ay bihirang, ngunit nangyari ito.

Mayroong dalawang mga paraan na maaari nating harapin ang mga pagkakamali. Ang isa ay upang huwag pansinin ang mga ito. Maaari naming isulat ang mga ito sa salaysay ng laro. Maraming mga bagyo sa dagat. Minsan humantong ito sa isang barko na masisira sa isang pag-atake kahit na ito ay immune. O nakaligtas sa isang pag-atake na dapat masira ito.

Ang pangalawang paraan upang harapin ang mga pagkakamali ay upang subukang alisin ang kanilang mga epekto. Kung maraming mga qubits ay magagamit, magagawa namin ito sa pagwawasto ng error ng dami. Sa kasamaang palad, may ilang taon pa rin.

Sa halip ay gagawa kami ng ilang mga istatistika. Para sa kailangan namin ng mga probabilidad, na nakukuha namin sa pamamagitan ng pagpapatakbo ng bawat trabaho nang maraming beses at nakikita kung gaano kadalas ang bawat posibleng resulta ay dumating.

Sa kaso ng walang ingay, ang mga posibilidad ay lahat ay 0%, 100% o 50%. Ang isang resulta ay maaaring imposible (tulad ng pagkuha ng 1 kung ang estado ay 0), tiyak (tulad ng pagkuha ng isang + kung ang estado ay +) o ganap na random (tulad ng pagkuha ng 0 kapag ang estado ay +).

Maingay ang ingay ng mga ito. Kapag gumawa kami ng isang 0/1 pagsukat ng isang 0, maaari naming makita na ang resulta 0 ay nangyayari lamang 98% ng oras, na may 2% pupunta para sa 1 sa halip. Upang iwasto ito ay gagawa tayo ng isang bagay na medyo di-makatwiran. Kami ay magpapasya na ang anumang bagay na may mas mababa sa isang 5% na posibilidad ay hindi kailanman nangyari. Ang anumang bagay na may higit sa isang 95% na posibilidad ay dapat na tiyak.

Pagsasama-sama ng lahat

Sakop ng artikulong ito ang malawak na mga stroke ng mekaniko ng laro para sa bersyon na ito ng Battleships, at kung paano ipatupad ito sa isang computer na quantum. Sa halip na dumaan sa lahat ng mga nakakatawang detalye ng mga detalye, maiiwan ko iyon para sa mga komento sa aktwal na code ng mapagkukunan.

Kung mayroong anumang iniisip na kailangan mo ng karagdagang paliwanag, huwag mag-atubiling ipaalam sa akin.