Základy kvantových výpočtů v Q#Quantum basics with Q#

V tomto Rychlém startu vám ukážeme, jak v jazyce Q# napsat program, který manipuluje s qubity, měří je a demonstruje efekty superpozice a provázání.In this Quickstart, we show you how to write a Q# program that manipulates and measures qubits and demonstrates the effects of superposition and entanglement. Tento dokument vás provede instalací sady QDK, sestavením programu a spuštěním programu na kvantovém simulátoru.This guides you on installing the QDK, building the program and executing that program on a quantum simulator.

Vytvoříme aplikaci nazvanou Bell, která demonstruje kvantové provázání.You will write an application called Bell to demonstrate quantum entanglement. Název Bell odkazuje na Bellovy stavy, což jsou specifické kvantové stavy 2 qubitů používané k demonstraci nejjednodušších příkladů superpozice a provázání.The name Bell is in reference to Bell states, which are specific quantum states of two qubits that are used to represent the simplest examples of superposition and quantum entanglement.

PožadavkyPre-requisites

Chcete-li se pustit do kódování, nejprve proveďte tyto kroky:If you are ready to start coding, follow these steps before proceeding:

  • Instalace vývojové sady s použitím preferovaného jazykového a vývojového prostředíInstall the Quantum Development Kit using your preferred language and development environment
  • Pokud už máte sadu QDK nainstalovanou, zkontrolujte, že je aktualizovaná na nejnovější verziIf you already have the QDK installed, make sure you have updated to the latest version

Pokud se chcete jen seznámit se základy, můžete si článek přečíst i bez instalace sady QDK. Získáte tak přehled o programovacím jazyku Q# a základních koncepcích kvantových výpočtů.You can also follow along with the narrative without installing the QDK, reviewing the overviews of the Q# programming language and the first concepts of quantum computing.

Demonstrace chování qubitů pomocí Q#Demonstrating qubit behavior with Q#

Připomeňme si naši jednoduchou definici qubitu.Recall our simple definition of a qubit. Zatímco klasické bity obsahují jednu binární hodnotu (tj. 0 nebo 1), qubit se může současně nacházet v superpozici stavů 0 a 1.Where classical bits hold a single binary value such as a 0 or 1, the state of a qubit can be in a superposition of 0 and 1 simultaneously. Qubit si můžete představit jako směr v prostoru (označuje se také jako vektor).Conceptually, a qubit can be thought of as a direction in space (also known as a vector). Qubit může být natočený do libovolného směru.A qubit can be in any of the possible directions. Dva klasické stavy odpovídají dvěma směrům. Představují 100% šanci na změření 0 a 100% šanci na změření 1.The two classical states are the two directions; representing 100% chance of measuring 0 and 100% chance of measuring 1. Tuto reprezentaci je možné formálněji vizualizovat Blochovou koulí.This representation is also more formally visualized by the bloch sphere.

Akce měření poskytuje binární výsledek a mění stav qubitu.The act of measurement produces a binary result and changes a qubit state. Měřením získáme binární hodnotu, buď 0, nebo 1.Measurement produces a binary value, either 0 or 1. V důsledku měření přejde qubit ze superpozice (libovolného směru) do jednoho z klasických stavů.The qubit goes from being in superposition (any direction) to one of the classical states. Všechna následná opakovaná měření bez provedení dalších operací už budou poskytovat shodný binární výsledek.Thereafter, repeating the same measurement without any intervening operations produces the same binary result.

Několik qubitů může být také provázáno.Multiple qubits can be entangled. Když změříme jeden provázaný qubit, změní se tím naše znalost stavu ostatních qubitů.When we make a measurement of one entangled qubit, our knowledge of the state of the other(s) is updated as well.

Nyní jsme připraveni ukázat, jak se toto chování vyjadřuje v jazyce Q#.Now, we're ready to demonstrate how Q# expresses this behavior. Začneme s nejjednodušším možným programem a sestavíme ho tak, abychom demonstrovali kvantovou superpozici a provázání.You start with the simplest program possible and build it up to demonstrate quantum superposition and quantum entanglement.

NastaveníSetup

Aplikace vyvinuté pomocí nástroje Microsoft Quantum Development Kit se skládají ze dvou částí:Applications developed with Microsoft's Quantum Development Kit consist of two parts:

  1. Jeden nebo více kvantových algoritmů, implementovaných v kvantovém programovacím jazyce Q#.One or more quantum algorithms, implemented using the Q# quantum programming language.
  2. Hostitelský program implementovaný v programovacím jazyce jako Python nebo C#, který slouží jako hlavní vstupní bod a vyvolává kvantové algoritmy jako operace Q#.A host program, implemented in a programming language like Python or C# that serves as the main entry point and invokes Q# operations to execute a quantum algorithm.
  1. Vyberte umístění aplikace.Choose a location for your application

  2. Vytvořte soubor s názvem Bell.qs.Create a file called Bell.qs. Tento soubor bude obsahovat váš kód Q#.This file will contain your Q# code.

  3. Vytvořte soubor s názvem host.py.Create a file called host.py. Tento soubor bude obsahovat váš hostitelský kód v Pythonu.This file will contain your Python host code.

Napište operaci Q#Write a Q# operation

Naším cílem je připravit dva qubity v určitém kvantovém stavu a demonstrovat tak, jak v Q# pracovat s qubity, měnit jejich stav a využívat efekty superpozice a provázání.Our goal is to prepare two qubits in a specific quantum state, demonstrating how to operate on qubits with Q# to change their state and demonstrate the effects of superposition and entanglement. Program sestavíme krok za krokem a předvedeme si stavy, operace a měření spojené s qubity.We will build this up piece by piece to demonstrate qubit states, operations, and measurement.

Přehled: V prvním kódu níže si ukážeme, jak v jazyce Q# pracovat s qubity.Overview: In the first code below, we show you how to work with qubits in Q#. Zavedeme dvě operace M a X, které mění stav qubitu.We’ll introduce two operations, M and X that transform the state of a qubit.

V tomto fragmentu kódu je použita operace Set, která přijímá jako parametr qubit a další parametr desired označující stav, do kterého chceme qubit převést.In this code snippet, an operation Set is defined that takes as a parameter a qubit and another parameter, desired, representing the state that we would like the qubit to be in. Operace Set provádí měření qubitu pomocí operace M.The operation Set performs a measurement on the qubit using the operation M. V Q# vrací měření qubitu vždy buď Zero, nebo One.In Q#, a qubit measurement always returns either Zero or One. Pokud měření vrátí hodnotu, která není rovna požadované hodnotě, operace Set qubit „překlopí“. To znamená, že provede operaci X, která změní stav qubit na nový stav, ve kterém jsou pravděpodobnosti změření Zero a One převrácené.If the measurement returns a value not equal to a desired value, Set “flips” the qubit; that is, it executes an X operation, which changes the qubit state to a new state in which the probabilities of a measurement returning Zero and One are reversed. Pro předvedení efektu operace Set je pak přidána operace TestBellState.To demonstrate the effect of the Set operation, a TestBellState operation is then added. Tato operace jako vstup přebírá Zero nebo One, několikrát s tímto vstupem zavolá operaci Set a spočítá, kolikrát byla z měření qubitu vrácena hodnota Zero a kolikrát One.This operation takes as input a Zero or One, and calls the Set operation some number of times with that input, and counts the number of times that Zero was returned from the measurement of the qubit and the number of times that One was returned. Samozřejmě v této první simulaci operace TestBellState očekáváme, že všechna měření qubitu nastaveného pomocí vstupního parametru Zero vrátí hodnotu Zero a všechna měření qubitu nastaveného pomocí parametru One vrátí One.Of course, in this first simulation of the TestBellState operation, we expect that the output will show that all measurements of the qubit set with Zero as the parameter input will return Zero, and all measurements of a qubit set with One as the parameter input will return One. Dále do operace TestBellState přidáme kód pro demonstraci superpozice a provázání.Further on, we’ll add code to TestBellState to demonstrating superposition and entanglement.

Kód operace Q#Q# operation code

  1. Obsah souboru Bell.qs nahraďte následujícím kódem:Replace the contents of the Bell.qs file with the following code:

    namespace Quantum.Bell {
        open Microsoft.Quantum.Intrinsic;
        open Microsoft.Quantum.Canon;
    
        operation Set(desired : Result, q1 : Qubit) : Unit {
            if (desired != M(q1)) {
                X(q1);
            }
        }
    }
    

    Teď můžeme zavolat tuto operaci, aby nastavila qubit do klasického stavu a vrátila buď hodnotu Zero ve 100 % případů, nebo hodnotu One ve 100 % případů.This operation may now be called to set a qubit to a classical state, either returning Zero 100% of the time or returning One 100% of the time. Zero a One jsou konstanty, které představují pouze dva možné výsledky měření stavu qubitu.Zero and One are constants that represent the only two possible results of a measurement of a qubit.

    Operace Set měří qubit.The operation Set measures the qubit. Pokud je qubit ve stavu, který chceme, Set ho nechá být, v opačném případě provedením operace X změní stav qubitu na požadovaný stav.If the qubit is in the state we want, Set leaves it alone; otherwise, by executing the X operation, we change the qubit state to the desired state.

Operace v jazyce Q#About Q# operations

Operace Q # je vlastně kvantový podprogram.A Q# operation is a quantum subroutine. To znamená, že se jedná o volanou rutinu, která obsahuje kvantové operace.That is, it is a callable routine that contains quantum operations.

Argumenty operace jsou zadány jako řazené kolekce členů v závorkách.The arguments to an operation are specified as a tuple, within parentheses.

Návratový typ operace je určen za dvojtečkou.The return type of the operation is specified after a colon. V našem případě operace Set nic nevrací, takže je označena jako vracející Unit.In this case, the Set operation has no return, so it is marked as returning Unit. Toto je v jazyce Q# ekvivalentem pojmu unit v F#, což je hrubá analogie void v C# a prázdné řazené kolekci členů v Pythonu (Tuple[()]).This is the Q# equivalent of unit in F#, which is roughly analogous to void in C#, and an empty tuple (Tuple[()]) in Python.

V naší první operaci Q# jsme použili dvě kvantové operace:You have used two quantum operations in your first Q# operation:

  • Operaci M, která měří stav qubitu.The M operation, which measures the state of the qubit
  • Operaci X, která převrací stav qubitu.The X operation, which flips the state of a qubit

Kvantová operace mění stav qubitu.A quantum operation transforms the state of a qubit. Někdy se mluví o kvantových hradlech místo kvantových operacích, je totiž možná i analogie s klasickými logickými hradly.Sometime people talk about quantum gates instead of operations, in analogy to classical logic gates. Tento koncept pochází z raných dob kvantových výpočtů, kdy byly algoritmy jen teoretické konstrukce a vizualizovaly se ve formě schémat odpovídacích obvodovým schématům klasických počítačů.This is rooted in the early days of quantum computing when algorithms were merely a theoretical construct and visualized as diagrams similarly to circuit diagrams in classical computing.

Přidání testovacího kódu Q#Add Q# test code

  1. Přidejte do souboru Bell.qs následující operaci, do oboru názvů za konec operace Set:Add the following operation to the Bell.qs file, inside the namespace, after the end of the Set operation:

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {
    
        mutable numOnes = 0;
        using (qubit = Qubit()) {
    
            for (test in 1..count) {
                Set(initial, qubit);
                let res = M(qubit);
    
                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            Set(Zero, qubit);
        }
    
        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes);
    }
    

    Tato operace (TestBellState) se zopakuje v count iteracích, v každé nastaví zadanou hodnotu qubitu initial a pak změří výsledek (M).This operation (TestBellState) will loop for count iterations, set a specified initial value on a qubit and then measure (M) the result. Shromáždí statistiku o počtu naměřených nul a jedniček a vrátí je volajícímu.It will gather statistics on how many zeros and ones we've measured and return them to the caller. Provede ale ještě jednu důležitou operaci.It performs one other necessary operation. Před návratem resetuje qubit do známého stavu (Zero), aby ostatní mohli tento qubit použít ve známém stavu.It resets the qubit to a known state (Zero) before returning it allowing others to allocate this qubit in a known state. To je provedeno příkazem using.This is required by the using statement.

Proměnné v jazyce Q#About variables in Q#

Ve výchozím nastavení jsou proměnné v Q# neměnné; po jejich svázání už je nelze změnit.By default, variables in Q# are immutable; their value may not be changed after they are bound. Klíčové slovo let slouží k označení vazby neměnné proměnné.The let keyword is used to indicate the binding of an immutable variable. Argumenty operace jsou vždycky neměnné.Operation arguments are always immutable.

Pokud potřebujete proměnnou, jejíž hodnotu je možné změnit, například numOnes v našem příkladu, můžete proměnnou deklarovat pomocí klíčového slova mutable.If you need a variable whose value can change, such as numOnes in the example, you can declare the variable with the mutable keyword. Hodnotu proměnlivé proměnné lze změnit pomocí příkazu set.A mutable variable's value may be changed using a set statement.

V obou případech je typ proměnné odvozen kompilátorem.In both cases, the type of a variable is inferred by the compiler. Q# nevyžaduje pro proměnné žádné specifikace typu.Q# doesn't require any type annotations for variables.

Příkazy using v Q#About using statements in Q#

Příkaz using je také jedinečný pro jazyk Q#.The using statement is also special to Q#. Slouží k přidělení qubitů pro použití v bloku kódu.It is used to allocate qubits for use in a block of code. V Q# se všechny qubity dynamicky přidělují a uvolňují, protože se nejedná o pevné prostředky, které jsou k dispozici pro celou dobu běhu složitého algoritmu.In Q#, all qubits are dynamically allocated and released, rather than being fixed resources that are there for the entire lifetime of a complex algorithm. Příkaz using přidělí sadu qubitů na začátku a uvolní je na konci bloku.A using statement allocates a set of qubits at the start, and releases those qubits at the end of the block.

Vytvořte kód hostitelské aplikaceCreate the host application code

  1. Otevřete soubor host.py a přidejte následující kód:Open the host.py file and add the following code:

    import qsharp
    
    from qsharp import Result
    from Quantum.Bell import TestBellState
    
    initials = (Result.Zero, Result.One)
    
    for i in initials:
      res = TestBellState.simulate(count=1000, initial=i)
      (num_zeros, num_ones) = res
      print(f'Init:{i: <4} 0s={num_zeros: <4} 1s={num_ones: <4}')
    

Kód hostitelské aplikaceAbout the host application code

Hostitelská aplikace v jazyce Python má tři části:The Python host application has three parts:

  • Vypočítá všechny argumenty vyžadované pro kvantový algoritmus.Compute any arguments required for the quantum algorithm. V příkladu je proměnná count nastavena pevně na 1000 a počáteční hodnota qubitu je initial.In the example, count is fixed at a 1000 and initial is the initial value of the qubit.
  • Spusťte kvantový algoritmus zavoláním metody simulate() importované operace Q#.Run the quantum algorithm by calling the simulate() method of the imported Q# operation.
  • Zpracujte výsledek operace.Process the result of the operation. V příkladu bude res obsahovat výsledek operace.In the example, res receives the result of the operation. Zde je výsledkem řazená kolekce členů – počet nul (num_zeros) a počet jedniček (num_ones) změřených simulátorem.Here the result is a tuple of the number of zeros (num_zeros) and number of ones (num_ones) measured by the simulator. Z řazené kolekce členů získáme dvě pole a vytiskneme výsledky.We deconstruct the tuple to get the two fields, and print the results.

Sestavení a spuštěníBuild and run

  1. Zadejte v okně terminálu následující příkaz:Run the following command at your terminal:

    python host.py
    

    Tento příkaz spustí hostitelskou aplikaci, která provede simulaci operace Q#.This command runs the host application, which simulates the Q# operation.

Výsledky by měly být:The results should be:

Init:0    0s=1000 1s=0   
Init:1    0s=0    1s=1000

Příprava superpozicePrepare superposition

Přehled Nyní se podíváme na to, jak Q# vyjadřuje způsoby, jak uvést qubity do superpozice.Overview Now let’s look at how Q# expresses ways to put qubits in superposition. Připomeňme si, že stav qubitu může být superpozicí hodnot 0 a 1.Recall that the state of a qubit can be in a superposition of 0 and 1. Dosáhneme toho operací Hadamard.We’ll use the Hadamard operation to accomplish this. Pokud je qubit v některém z klasických stavů (kdy měření vrátí vždy Zero nebo vždy One), pak operace Hadamard nebo H převede qubit do stavu, ve kterém měření vrátí v 50 % případů Zero a v 50 % případů One.If the qubit is in either of the classical states (where a measurement returns Zero always or One always), then the Hadamard or H operation will put the qubit in a state where a measurement of the qubit will return Zero 50% of the time and return One 50% of the time. Můžete si to představit tak, že qubit je uprostřed mezi Zero a One.Conceputually, the qubit can be thought of as halfway between the Zero and One. Když teď budeme simulovat operaci TestBellState, uvidíme, že jednotlivá měření vrátí přibližně stejný počet hodnot Zero a One.Now, when we simulate the TestBellState operation, we will see the results will return roughly an equal number of Zero and One after measurement.

Nejdřív zkusíme qubit překlopit (pokud je qubit ve stavu Zero, překlopíme ho na One a naopak).First we'll just try to flip the qubit (if the qubit is in Zero state will flip to One and vice versa). Toho se dosáhne použitím operace X před změřením v operaci TestBellState:This is accomplished by performing an X operation before we measure it in TestBellState:

X(qubit);
let res = M(qubit);

Nyní jsou výsledky (po stisknutí F5) obrácené:Now the results (after pressing F5) are reversed:

Init:Zero 0s=0    1s=1000
Init:One  0s=1000 1s=0

Ovšem všechno, co jsme doposud viděli, je klasické.However, everything we've seen so far is classical. Pojďme se dostat ke kvantovým výsledkům.Let's get a quantum result. Stačí k tomu nahradit operaci X v předchozím běhu operací H (Hadamard).All we need to do is replace the X operation in the previous run with an H or Hadamard operation. Místo úplného překlopení qubitu z 0 na 1 ho můžeme překlopit jen napůl.Instead of flipping the qubit all the way from 0 to 1, we will only flip it halfway. Změněné řádky v TestBellState teď vypadají takto:The replaced lines in TestBellState now look like:

H(qubit);
let res = M(qubit);

Teď už výsledky budou zajímavější:Now the results get more interesting:

Init:Zero 0s=484  1s=516
Init:One  0s=522  1s=478

Každým měřením požádáme o klasickou hodnotu, ale qubit je uprostřed mezi 0 a 1, takže (statisticky) dostaneme v polovině případů 0 a v polovině případů 1.Every time we measure, we ask for a classical value, but the qubit is halfway between 0 and 1, so we get (statistically) 0 half the time and 1 half the time. To se označuje jako superpozice a je to naše první seznámení s kvantovými stavy.This is known as superposition and gives us our first real view into a quantum state.

Příprava provázáníPrepare entanglement

Přehled: Teď se podíváme na to, jak se v Q# vyjadřuje kvantové provázání qubitů.Overview: Now let’s look at how Q# expresses ways to entangle qubits. Nejdřív uvedeme první qubit do počátečního stavu a pak ho pomocí operace H převedeme do superpozice.First, we set the first qubit to the initial state and then use the H operation to put it into superposition. Pak před změřením prvního qubitu použijeme novou operaci CNOT, což je zkratka pro Controlled-Not, kontrolovanou negaci.Then, before we measure the first qubit, we use a new operation (CNOT), which stands for Controlled-Not. Výsledkem provedení této operace na dvou qubitech je překlopení druhého qubitu, pokud je první ve stavu One.The result of executing this operation on two qubits is to flip the second qubit if the first qubit is One. Nyní máme dva provázané qubity.Now, the two qubits are entangled. Statistika prvního qubitu se nezměnila (stále šance 50-50, že měřením získáme Zero nebo One), ale když teď změříme stav druhého qubitu, bude vždy stejný jako stav naměřený u toho prvního.Our statistics for the first qubit haven't changed (50-50 chance of a Zero or a One after measurement), but now when we measure the second qubit, it is always the same as what we measured for the first qubit. Operace CNOT provázala oba qubity, takže cokoli se stane jednomu, stane se i druhému.Our CNOT has entangled the two qubits, so that whatever happens to one of them, happens to the other. Když pořadí měření otočíme (změříme nejprve druhý a pak první qubit), dostaneme úplně stejný výsledek.If you reversed the measurements (did the second qubit before the first), the same thing would happen. První měření bude náhodné, ale druhé bude přesně kopírovat výsledek toho prvního.The first measurement would be random and the second would be in lock step with whatever was discovered for the first.

První věc, kterou je potřeba udělat, je přidělit v operaci TestBellState dva qubity místo jednoho:The first thing we'll need to do is allocate 2 qubits instead of one in TestBellState:

using ((q0, q1) = (Qubit(), Qubit())) {

To nám umožní přidat novou operaci (CNOT) před změřením (M) v operaci TestBellState:This will allow us to add a new operation (CNOT) before we measure (M) in TestBellState:

Set(initial, q0);
Set(Zero, q1);

H(q0);
CNOT(q0, q1);
let res = M(q0);

Přidali jsme další operaci Set inicializující první qubit, abychom se ujistili, že je vždy v počátečním stavu Zero.We've added another Set operation to initialize the first qubit to make sure that it's always in the Zero state when we start.

Stejně tak musíme resetovat druhý qubit, než ho na konci uvolníme.We also need to reset the second qubit before releasing it.

Set(Zero, q0);
Set(Zero, q1);

Úplná rutina teď vypadá takto:The full routine now looks like this:

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {

        mutable numOnes = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                Set (initial, q0);
                Set (Zero, q1);

                H(q0);
                CNOT(q0,q1);
                let res = M(q0);

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            
            Set(Zero, q0);
            Set(Zero, q1);
        }

        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes);
    }

Když ji spustíme, získáme přesně stejný výsledek 50-50, jako předtím.If we run this, we'll get exactly the same 50-50 result we got before. Co nás ale zajímá je způsob, jakým druhý qubit reaguje na první měřenou hodnotu.However, what we're interested in is how the second qubit reacts to the first being measured. Tuto statistiku přidáme s novou verzí operace TestBellState:We'll add this statistic with a new version of the TestBellState operation:

    operation TestBellState(count : Int, initial : Result) : (Int, Int, Int) {
        mutable numOnes = 0;
        mutable agree = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                Set(initial, q0);
                Set(Zero, q1);

                H(q0);
                CNOT(q0, q1);
                let res = M(q0);

                if (M(q1) == res) {
                    set agree += 1;
                }

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            
            Set(Zero, q0);
            Set(Zero, q1);
        }

        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes, agree);
    }

Nová návratová hodnota (agree) počítá případy, kdy se měření prvního qubitu shodovalo s měřením druhého qubitu.The new return value (agree) keeps track of every time the measurement from the first qubit matches the measurement of the second qubit. Také je potřeba odpovídajícím způsobem aktualizovat hostitelskou aplikaci:We also have to update the host application accordingly:

import qsharp

from qsharp import Result
from Quantum.Bell import TestBellState

initials = {Result.Zero, Result.One} 

for i in initials:
    res = TestBellState.simulate(count=1000, initial=i)
    (num_zeros, num_ones, agree) = res
    print(f'Init:{i: <4} 0s={num_zeros: <4} 1s={num_ones: <4} agree={agree: <4}')

Po spuštění dostaneme moc zajímavý výsledek:Now when we run, we get something pretty amazing:

Init:Zero 0s=499  1s=501  agree=1000
Init:One  0s=490  1s=510  agree=1000

Jak jsme uvedli v přehledu, statistika prvního qubitu se nezměnila (stále šance 50:50, že získáme 0 nebo 1), ale teď když změříme stav druhého qubitu, bude vždy stejný, jako změřený stav toho prvního, protože jsou provázané!As stated in the overview, our statistics for the first qubit haven't changed (50-50 chance of a 0 or a 1), but now when we measure the second qubit, it is always the same as what we measured for the first qubit, because they are entangled!

Blahopřejeme, napsali jste svůj první kvantový program!Congratulations, you've written your first quantum program!

Co dále?What's next?

Dokument Groverův vyhledávací algoritmus vám ukáže, jak implementovat a spustit Groverovo vyhledávání, jeden z nejoblíbenějších kvantových výpočetních algoritmů, a nabízí dobrý příklad programu Q#, který se dá použít k řešení reálných problémů pomocí kvantových výpočtů.The QuickStart Grover’s search shows you how to build and run Grover search, one of the most popular quantum computing algorithms and offers a nice example of a Q# program that can be used to solve real problems with quantum computing.

Dokument Začínáme se sadou Quantum Development Kit vám nabídne další způsoby, jak se seznámit s jazykem Q# a kvantovými programy.Get Started with the Quantum Development Kit recommends more ways to learn Q# and quantum programming.