チュートリアル:Q# でのもつれの確認Tutorial: Explore entanglement with Q#

このチュートリアルでは、量子ビットの操作および測定を行い、重ね合わせともつれの効果を示す、Q# プログラムの作成方法を説明します。In this tutorial, we show you how to write a Q# program that manipulates and measures qubits and demonstrates the effects of superposition and entanglement.

量子のもつれを示すため、Bell というアプリケーションを記述します。You will write an application called Bell to demonstrate quantum entanglement. Bell という名前は、ベル状態を表しています。これは、量子の重ね合わせともつれの最も簡単な例を表すために使用される、2 つの量子ビットの特定の量子の状態です。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.

前提条件Pre-requisites

コーディングを開始する準備ができたら、続行する前に次の手順を実行してください。If you are ready to start coding, follow these steps before proceeding:

  • 任意の言語および開発環境を使用して、Quantum 開発キットをインストールします。Install the Quantum Development Kit using your preferred language and development environment.
  • 既に QDK をインストールしている場合は、バージョンが最新であることを確認するIf you already have the QDK installed, make sure you have updated to the latest version

また、QDK をインストールしなくても、Q # プログラミング言語の概要と、クォンタムコンピューティングの最初の概念を確認することで、このナレーションに従うことができます。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.

このチュートリアルでは、次の作業を行う方法について説明します。In this tutorial, you'll learn how to:

  • Q での操作の作成と結合#Create and combine operations in Q#
  • 法則、entangle に qubits を配置する操作を作成し、それらを測定します。Create operations to put qubits in superposition, entangle and measure them.
  • シミュレーターで実行される Q # プログラムを使用したクォンタムの例を示します。Demonstrate quantum entanglement with a Q# program run in a simulator.

QDK を使用した qubit 動作のデモンストレーションDemonstrating qubit behavior with the QDK

従来のビットでは単一のバイナリ値 (0、1 など) が保持されるのに対し、量子ビットの状態は 0 と 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. 概念上、qubit の状態は、抽象空間 (ベクターとも呼ばれます) の方向と考えることができます。Conceptually, the state of a qubit can be thought of as a direction in an abstract space (also known as a vector). Qubit 状態は、可能な任意の方向にすることができます。A qubit state can be in any of the possible directions. 2 つの従来の状態とは、0 を測定する確率が 100% になる方向と、1 を測定する確率が 100% になる方向のことです。The two classical states are the two directions; representing 100% chance of measuring 0 and 100% chance of measuring 1.

測定の動作により、2 進法の結果が生成され、量子ビットの状態が変わります。The act of measurement produces a binary result and changes a qubit state. 測定値によって、0または1の2進値が生成されます。Measurement produces a binary value, either 0 or 1. 量子ビットは重ね合わせ (あらゆる方向にある) の状態から古典的状態のいずれかになります。The qubit goes from being in superposition (any direction) to one of the classical states. その後、介在する操作なしで同じ測定を繰り返すと、同じ 2 進数の結果が生成されます。Thereafter, repeating the same measurement without any intervening operations produces the same binary result.

複数の量子ビットはもつれさせることができます。Multiple qubits can be entangled. もつれのある 1 つの量子ビットを測定すると、もう一方の量子ビットの状態に関する知識も更新されます。When we make a measurement of one entangled qubit, our knowledge of the state of the other(s) is updated as well.

これで、Q# がこの動作を表現する方法を説明できるようになりました。Now, we're ready to demonstrate how Q# expresses this behavior. 考えられる最も単純なプログラムから始め、量子の重ね合わせと量子のもつれを表すように構築します。You start with the simplest program possible and build it up to demonstrate quantum superposition and quantum entanglement.

Q # プロジェクトを作成するCreating a Q# project

まず、新しい Q # プロジェクトを作成する必要があります。The first thing we have to do is to create a new Q# project. このチュートリアルでは、 VS Code のコマンドラインアプリケーションに基づいて環境を使用します。In this tutorial we are going to use the environment based on command line applications with VS Code.

新しいプロジェクトを作成するには VS Code 次のようにします。To create a new project, in VS Code:

  1. [ View -> コマンドパレットの表示] をクリックし、[ Q #: 新しいプロジェクトの作成] を選択します。Click View -> Command Palette and select Q#: Create New Project.
  2. [スタンドアロンコンソールアプリケーション] をクリックします。Click Standalone console application.
  3. プロジェクトを保存する場所に移動し、[プロジェクトの作成] をクリックします。Navigate to the location to save the project and click Create Project.
  4. プロジェクトが正常に作成されたら、右下にある [新しいプロジェクトを開く] をクリックします。When the project is successfully created, click Open new project... in the lower right.

この例では、プロジェクトを呼び出しました BellIn this case we called the project Bell. これに Bell.csproj より、プロジェクトファイルと、アプリケーションを Program.qs 記述するために使用する Q # アプリケーションのテンプレートの2つのファイルが生成されます。This generates two files: Bell.csproj, the project file and Program.qs, a template of a Q# application that we will use to write our application. の内容は次のようになり Program.qs ます。The content of Program.qs should be:

   namespace Bell {

      open Microsoft.Quantum.Canon;
      open Microsoft.Quantum.Intrinsic;
    

      @EntryPoint()
      operation HelloQ() : Unit {
          Message("Hello quantum world!");
      }
   }

Q アプリケーションを作成する #Write the Q# application

私たちの目標は、Q# を使って量子ビットを操作してその状態を変更するための、特定の量子の状態にある 2 つの量子ビットを準備し、重ね合わせともつれの効果を示すことです。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. ここでは、qubit の状態、操作、および測定について説明します。We will build this up piece by piece to introduce qubit states, operations, and measurement.

測定を使用して qubit を初期化するInitialize qubit using measurement

以下に示す最初のコードは、Q# で量子ビットを操作する方法を示しています。In the first code below, we show you how to work with qubits in Q#. 2つの操作を紹介 M し、 X qubit の状態を変換します。We’ll introduce two operations, M and X that transform the state of a qubit. このコード スニペットでは、量子ビットをパラメーターと見なす操作 SetQubitState が定義されています。もう 1 つのパラメーター desired は量子ビットが目的とする状態を表しています。In this code snippet, an operation SetQubitState 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. 操作 SetQubitState は、操作 M を使用して、量子ビットに対する測定を実行します。The operation SetQubitState performs a measurement on the qubit using the operation M. Q # では、qubit 測定値は常に Zero またはを返し One ます。In Q#, a qubit measurement always returns either Zero or One. 測定値が目的の値と等しくない値を返す場合、 SetQubitState は qubit を "反転" します。つまり、演算子は演算を実行します。これにより、 X qubit 状態が戻り値の確率が返され、元に戻される新しい状態に変更 Zero され One ます。If the measurement returns a value not equal to the desired value, SetQubitState “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. これにより、は SetQubitState 常にターゲットの qubit を目的の状態にします。This way, SetQubitState always puts the target qubit in the desired state.

の内容を Program.qs 次のコードに置き換えます。Replace the contents of Program.qs with the following code:

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, q1 : Qubit) : Unit {
           if (desired != M(q1)) {
               X(q1);
           }
       }
   }

この操作により、量子ビットが従来の状態に設定されます。つまり、Zero が 100% 返されるか、One が 100% 返されるかのどちらかです。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 および One は、量子ビットの測定結果として考えられる 2 とおりの結果を表す定数です。Zero and One are constants that represent the only two possible results of a measurement of a qubit.

SetQubitState 操作で量子ビットが測定されます。The operation SetQubitState measures the qubit. 量子ビットが目的の状態にある場合は、SetQubitState をそのままにしておきます。それ以外の場合は、X 操作を実行することで量子ビットの状態が目的の状態に変更されます。If the qubit is in the state we want, SetQubitState leaves it alone; otherwise, by executing the X operation, we change the qubit state to the desired state.

Q# 操作についてAbout Q# operations

Q# 操作は、量子のサブルーチンです。A Q# operation is a quantum subroutine. つまり、これは、他のクォンタム操作の呼び出しを含む呼び出し可能なルーチンです。That is, it is a callable routine that contains calls to other quantum operations.

操作の引数は、かっこ内にタプルとして指定します。The arguments to an operation are specified as a tuple, within parentheses.

操作の戻り値の型は、コロンの後に指定します。The return type of the operation is specified after a colon. この場合、SetQubitState 操作には戻り値がないため、Unit を返すように設定されています。In this case, the SetQubitState operation has no return, so it is marked as returning Unit. これは、F# における unit の Q# 版にあたります。C# では void、Python では空のタプル (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.

最初の Q# 操作では、次の 2 つの量子操作を使用しました。You have used two quantum operations in your first Q# operation:

  • MQubit の状態を測定する操作。The M operation, which measures the state of the qubit
  • XQubit の状態を反転する操作。The X operation, which flips the state of a qubit

量子操作により、量子ビットの状態が変換されます。A quantum operation transforms the state of a qubit. 従来の論理ゲートの類義語として、量子操作の代わりに、量子ゲートが話題になることがあります。Sometime people talk about quantum gates instead of operations, in analogy to classical logic gates. これは初期の量子コンピューティングでは、アルゴリズムが単なる理論上の構成要素であり、古典コンピューティングの回路図に似た図で視覚化されていたことに端を発します。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.

測定結果のカウントCounting measurement outcomes

SetQubitState 操作の効果を示すため、TestBellState 操作を追加します。To demonstrate the effect of the SetQubitState operation, a TestBellState operation is then added. この操作では、Zero または One を入力として受け取り、その入力で SetQubitState 操作を何回か呼び出して、Zero が量子ビットの測定から返された回数と One が返された回数をカウントします。This operation takes as input a Zero or One, and calls the SetQubitState 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. 当然ながら、TestBellState 操作のこの最初のシミュレーションでは、Zero がパラメーターとして設定された量子ビットのすべての測定で Zero を返し、One がパラメーターとして設定された量子ビットのすべての測定で 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. さらに、 TestBellState 法則と entangを示すためのコードをに追加します。Further on, we’ll add code to TestBellState to demonstrate superposition and entanglement.

Bell.qs ファイルの名前空間内、SetQubitState 操作の終了後に次の操作を追加します。Add the following operation to the Bell.qs file, inside the namespace, after the end of the SetQubitState operation:

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

       mutable numOnes = 0;
       using (qubit = Qubit()) {

           for (test in 1..count) {
               SetQubitState(initial, qubit);
               let res = M(qubit);

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

       // Return number of times we saw a |0> and number of times we saw a |1>
       Message("Test results (# of 0s, # of 1s): ");
       return (count - numOnes, numOnes);
   }

returnコンソールで関数 () を使用して説明メッセージを出力するために、の前に行を追加しました MessageNote that we added a line before the return to print an explanatory message in the console with the function (Message)[microsoft.quantum.intrinsic.message]

この操作 (TestBellState) では、count 回ループし、指定された initial 値を量子ビットに設定して、結果を測定 (M) します。This operation (TestBellState) will loop for count iterations, set a specified initial value on a qubit and then measure (M) the result. これにより、測定した 0 と 1 の数がいくつあるかの統計情報が収集され、呼び出し元に返されます。It will gather statistics on how many zeros and ones we've measured and return them to the caller. ここでは、もう 1 つの必要な操作を実行しています。It performs one other necessary operation. 他のユーザーがこの量子ビットに既知の状態を割り当てることができるよう、終了する前にこの量子ビットを既知の状態 (Zero) にリセットします。It resets the qubit to a known state (Zero) before returning it allowing others to allocate this qubit in a known state. この操作は、using ステートメントに必須です。This is required by the using statement.

Q の変数について#About variables in Q#

既定では、Q# の変数は不変です。バインド後に変数の値を変更することはできません。By default, variables in Q# are immutable; their value may not be changed after they are bound. let キーワードは、不変変数のバインドを示すために使用します。The let keyword is used to indicate the binding of an immutable variable. 操作の引数は常に不変です。Operation arguments are always immutable.

先ほどの例の numOnes のように、値を変更できる変数が必要な場合は、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. 可変変数の値は、setQubitState ステートメントを使用して変更できます。A mutable variable's value may be changed using a setQubitState statement.

どちらの場合も、変数の型はコンパイラによって推論されます。In both cases, the type of a variable is inferred by the compiler. Q# では、変数に型の注釈は必要ありません。Q# doesn't require any type annotations for variables.

usingQ のステートメントについて#About using statements in Q#

using ステートメントも Q# に特有です。The using statement is also special to Q#. これは、コードのブロックで使用するために量子ビットを割り当てる場合に使用されます。It is used to allocate qubits for use in a block of code. Q# では、複雑なアルゴリズムの有効期間全体にわたってリソースが固定されるのではなく、すべての量子ビットが動的に割り当てられ、解放されます。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. using ステートメントは、ブロックの最初で一連の量子ビットを割り当て、ブロックの最後でその量子ビットを解放します。A using statement allocates a set of qubits at the start, and releases those qubits at the end of the block.

コマンドラインからコードを実行するExecute the code from the command line

コードを実行するには、コマンドを指定したときに実行される呼び出し可能なコンパイラを指定する必要があり dotnet run ます。In order to run the code we need to specify the compiler which callable to run when we provide the dotnet run command. これを行うには、呼び出し先の直前にを含む行を追加することにより、Q # ファイルを簡単に変更し @EntryPoint() ます。 TestBellState この場合は、操作です。This is done with a simple change in the Q# file by adding a line with @EntryPoint() directly preceding the callable: the TestBellState operation in this case. 完全なコードは次のようになります。The full code should be:

namespace Bell {
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if (desired != M(target)) {
            X(target);
        }
    }

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

        mutable numOnes = 0;
        using (qubit = Qubit()) {

            for (test in 1..count) {
                SetQubitState(initial, qubit);
                let res = M(qubit);

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

            SetQubitState(Zero, qubit);
        }

    // Return number of times we saw a |0> and number of times we saw a |1>
    Message("Test results (# of 0s, # of 1s): ");
    return (count - numOnes, numOnes);
    }
}

プログラムを実行するには、 count initial コマンドラインから引数と引数を指定する必要があります。To run the program we need to specify count and initial arguments from the command line. たとえば、とのように選択し count = 1000 initial = One ます。Let's choose for example count = 1000 and initial = One. 次のコマンドを入力します。Enter the following command:

dotnet run --count 1000 --initial One

次の出力が表示されます。And you should observe the following output:

Test results (# of 0s, # of 1s):
(0, 1000)

を試してみると、次のことを確認する initial = Zero 必要があります。If you try with initial = Zero you should observe:

dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(1000, 0)

重ね合わせ状態を作成するPrepare superposition

次に、Q # で法則に qubits を配置する方法を見てみましょう。Now let’s look at how Q# expresses ways to put qubits in superposition. 量子ビットの状態は、0 と 1 の重ね合わせにできることを思い出してください。Recall that the state of a qubit can be in a superposition of 0 and 1. これを行うには、Hadamard 操作を使用します。We’ll use the Hadamard operation to accomplish this. 量子ビットが従来の状態のいずれか (測定で常に One または Zero を返す) である場合、Hadamard (H) 操作によって、量子ビットの測定で 50% の Zero および 50% の 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. 概念上、量子ビットは ZeroOne の中間にあると考えることができます。Conceputually, the qubit can be thought of as halfway between the Zero and One. ここで、TestBellState 操作をシミュレートすると、測定後の結果は、ほぼ同数の ZeroOne を返します。Now, when we simulate the TestBellState operation, we will see the results will return roughly an equal number of Zero and One after measurement.

Xqubit 状態を反転しますX flips qubit state

まず、量子ビットを反転してみます (量子ビットが Zero の状態にある場合は One になり、その逆も同様になります)。First we'll just try to flip the qubit (if the qubit is in Zero state will flip to One and vice versa). これは、TestBellState で測定する前に X 操作を実行することで実現されます。This is accomplished by performing an X operation before we measure it in TestBellState:

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

結果は逆順になります。Now the results are reversed:

dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(1000, 0)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(0, 1000)

次に、qubits のクォンタムプロパティについて説明します。Now let's explore the quantum properties of the qubits.

H法則を準備するH prepares superposition

必要なのは、先ほどの実行の X 操作を H すなわち Hadamard 操作に置き換えることだけです。All we need to do is replace the X operation in the previous run with an H or Hadamard operation. これは、量子ビットを 0 から 1 まで完全に反転させるのではなく、半分だけ反転します。Instead of flipping the qubit all the way from 0 to 1, we will only flip it halfway. TestBellState の行を置き換えると、次のようになります。The replaced lines in TestBellState now look like:

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

結果はさらに興味深いものになります。Now the results get more interesting:

dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(496, 504)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(506, 494)

測定するたびに、従来型の値が要求されますが、量子ビットは 0 と 1 の中間にあるため、(統計的に) 半分が 0、半分が 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. これは重ね合わせと呼ばれる現象で、これによって初めて量子状態を実際に観測できます。This is known as superposition and gives us our first real view into a quantum state.

もつれ状態を作成するPrepare entanglement

では、Q# がどのように量子ビットのもつれを表現するかを見てみましょう。Now let’s look at how Q# expresses ways to entangle qubits. まず、最初の量子ビットを初期状態に設定してから、H 操作を使用してそれを重ね合わせに配置します。First, we set the first qubit to the initial state and then use the H operation to put it into superposition. 次に、最初の qubit を測定する前に、 CNOT 制御されていないを表す新しい操作 () を使用します。Then, before we measure the first qubit, we use a new operation (CNOT), which stands for Controlled-NOT. 2 つの量子ビットに対してこの操作を実行した結果、最初の量子ビットが One である場合には 2 番目の量子ビットが反転されます。The result of executing this operation on two qubits is to flip the second qubit if the first qubit is One. これで、2 つの量子ビットがもつれ状態になります。Now, the two qubits are entangled. 最初の量子ビットの統計情報は変わっていませんが (測定後、50-50 の確率で Zero または One)、2 番目の量子ビットを測定すると、最初の量子ビットを測定した結果と__常に__同じになります。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. この CNOT が 2 つの量子ビットをもつれさせ、片方に何かが起きると、もう片方にも同じことが起こるようになっています。Our CNOT has entangled the two qubits, so that whatever happens to one of them, happens to the other. 測定を反対にしても (最初の量子ビットの前に 2 番目の量子ビットを測定する)、同じことが起こります。If you reversed the measurements (did the second qubit before the first), the same thing would happen. 最初の測定値はランダムであり、2 回目の測定値は最初に検出されたものと完全に一致します。The first measurement would be random and the second would be in lock step with whatever was discovered for the first.

最初に、ではなく2つの qubits を割り当てる必要があり TestBellState ます。The first thing we'll need to do is allocate two qubits instead of one in TestBellState:

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

これにより、TestBellState で測定 (M) する前に、新しい操作 (CNOT) を追加できます。This will allow us to add a new operation (CNOT) before we measure (M) in TestBellState:

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

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

最初の量子ビットを初期化するために別の SetQubitState 操作を追加し、開始時に常に Zero 状態になるようにしました。We've added another SetQubitState operation to initialize the first qubit to make sure that it's always in the Zero state when we start.

また、2 番目の量子ビットを解放する前にリセットする必要があります。We also need to reset the second qubit before releasing it.

SetQubitState(Zero, q0);
SetQubitState(Zero, q1);

完全なルーチンは、次のようになります。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) {
                SetQubitState(initial, q0);
                SetQubitState(Zero, q1);

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

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

            SetQubitState(Zero, q0);
            SetQubitState(Zero, q1);
        }

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

これを実行すると、以前とまったく同じ 50-50 の結果が得られます。If we run this, we'll get exactly the same 50-50 result we got before. しかし、ここで興味深いのは、2 番目の量子ビットが測定される最初の量子ビットに対してどのように反応するかです。However, what we're interested in is how the second qubit reacts to the first being measured. この統計情報は、新しいバージョンの 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) {
                SetQubitState(initial, q0);
                SetQubitState(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;
                }
            }
            
            SetQubitState(Zero, q0);
            SetQubitState(Zero, q1);
        }

        // Return times we saw |0>, times we saw |1>, and times measurements agreed
        Message("Test results (# of 0s, # of 1s, # of agreements)");
        return (count-numOnes, numOnes, agree);
    }

新しい戻り値 (agree) は、最初の量子ビットの測定値が 2 番目の量子ビットの測定値と一致した回数を追跡します。The new return value (agree) keeps track of every time the measurement from the first qubit matches the measurement of the second qubit.

取得したコードを実行すると、次のようになります。Running the code we obtain:

dotnet run --count 1000 --initial One
(505, 495, 1000)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s, # of agreements)
(507, 493, 1000)

概要で述べたように、最初の量子ビットの統計情報は変わっていませんが (50-50 の確率で 0 または 1)、2 番目の量子ビットを測定すると、最初の量子ビットを測定した結果と__常に__同じになります。これは、もつれ状態にあるからです。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!

次のステップNext steps

グローバーの検索のチュートリアルでは、最も人気のある量子コンピューティング アルゴリズムの 1 つである、グローバーの検索をビルドして実行する方法を示しています。また、量子コンピューティングに関する実際の問題を解決するために使用できる Q# プログラムの優れた例を紹介しています。The tutorial 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.

Get Started with the Quantum Development Kit」(Quantum Development Kit の概要) では、Q# と量子コンピューティングのその他の学習方法も紹介しています。Get Started with the Quantum Development Kit recommends more ways to learn Q# and quantum programming.